He's an excellent teacher and has taught many popular courses. Hey, how's it going, everyone? I just wanted to welcome you to my Python API development course.

So in this course, I'm going to walk you through building out your very own API in Python. However, keep in mind, this course is so much more than just building out a simple API. In fact,

as I'm sure you saw the video length, this course does come out to a whopping 19 hours in length. And so you're probably wondering, well, what exactly are we going to be covering for 19 hours?

We don't need 19 hours to create an API. Well, first of all, we're going to build out a fully featured API that includes authentication, current operations, scheme of validation,

and we're going to set up documentation for our API, because that's very important. However, the learning doesn't stop just there. This course is going to extend well past just

basic API development. We'll also learn all of the tooling that surrounds building a complete and robust API. I've dedicated a large section of this course to learning SQL. And I've noticed

that a lot of the other API and web development courses, they just quickly gloss over SQL without diving into the nitty gritty of how SQL databases work. For this course, we're going to cover SQL

extensively. And we're going to start from the absolute basics. So you don't need to know a single thing about databases or SQL in general. But by the time you complete this course, you

will be very proficient at generating database schemas, you'll know core SQL concepts like primary keys, foreign keys, table constraints, and you can pretty much be able to generate SQL

queries to grab the exact data that you're looking for. And on top of that, I'll show you how to integrate your SQL databases in your API using two different methods. So we'll cover both using raw

SQL queries as well as ORMs so that no matter which method you ultimately prefer, you'll have

all the skills and resources to start building out your own projects. We'll also familiarize

ourselves with database migration tools like alembic, which allow us to make incremental changes to our database schema to track changes and get just like we can with our regular Python

code. We'll also learn how to use tools like postman to construct HTTP packets so that we

could test our API during the whole development process. And when it comes to testing, I've added about you know, two to three hours of content going over how to set up automated integration

tests so that when you make changes to your code, you can run these automated tests to verify that your code changes haven't broke any pre existing functionality. And then after testing, we're going

to move on to the deployment phase, we're going to actually deploy our application. And I didn't just include one method of deployment, I've actually included two different deployment scenarios.

The first scenario is probably the most common scenario, which is deploying our app onto like an Ubuntu machine that can be hosted on any cloud provider like AWS, GCP, Azure, or even digital

ocean. And you know, we'll cover things like how to set up nginx to act as a reverse proxy, we'll, we'll configure our own system D service, we'll set up a firewall to block all non HTTP

traffic. And we'll even set up SSL so that our application can handle HTTPS traffic. But after

that, we'll also take a look at how we can deploy our application onto Heroku. Just because if you don't have, you know, maybe you can't afford to pay for cloud services, or you just don't have the

ability to sign up for an account or something like that, I do want to make sure that you still have a way of deploying your applications that you can show off to your friends and family what you

created. So I added the Heroku section, because they've got a very, very nice and convenient free

tier where we can deploy our entire application for free, we don't need to sign up with the credit card. So that's why I included that second deployment scenario. And since all the cool

kids are hardcore into Docker today, I'm going to show you how to Dockerize your API in case that is your preferred method of deployment. And then finally, we're going to wrap things up by building

out our very own CI CD pipeline using GitHub actions. This will allow us to push out changes

to GitHub, resulting in our pipeline running, which will pull our code, run all of our integration tests, build all of the necessary images. And if all the tests ultimately pass, it'll actually push

out our changes to our production environment, so that we can do all of this in an automated fashion without having to manually go in and run each step manually. So let's take a look at our tech stack.

Since this is a Python API course, we will be using Python to build out our API. There were a couple of different web frameworks in Python that we could have used most notably Django and

flask, I decided to use neither one of them. And I decided to use a newer framework called fast API.

And the reason why I chose to use this framework was because it has API's kind of built in mind,

right? It wasn't there to address like the model view controller type scenario, it really is all about building out API's. And on top of that, it is really fast, right? But when I say fast,

it's not just fast from a performance perspective, which it is. But it's also fast from the fact that it can, it makes it really easy and quick to spin up new API's. And one of my favorite features

of this framework is the auto documentation functionality. When you build an API, you have

to document how your API works. And this is a very cumbersome task. Because anytime you make any changes to your API, you have to remember to update your API, or then the front end can be

making the wrong request. Fast API automatically documents your API for you so that you don't have to do it yourself. It's truly a game changer. And finally, the most important reason why I chose

fast API is because of this. You see this magnificent beast? This is the creator of the

fast API framework. And my mom always told me when someone with a mustache as glorious as that

creates a web framework, you use that damn framework. Now, as I mentioned, we will be covering

SQL extensively. And I've decided to go with Postgres. It doesn't really matter what type of SQL

database you use. They're all fundamentally the same with only minor differences. I chose Postgres because that's my favorite. And who doesn't like elephants anyways, for our ORM,

when we do eventually migrate to ORMs from using raw SQL queries, we will be using SQL alchemy.

I decided to use that because that seems like that's the most standard one for Python. I really could have chose any of them. I didn't really care which one I used. So I just picked the most popular

one. So that covers our tech stack. Let's now take a look at the project that we'll be building.

Now I would love to show you some cool flashy website that you can show off to your friends. However, we're not building a website, we're building an API. And unfortunately,

API's don't really have a visual aspect to them. So I don't really have anything to show you. I mean, I could I guess construct a couple of HTTP packets that send it and verify that we get the

proper JSON response. But that's not really exciting. So I'm going to do is I'm going to show you our documentation for our project so that you can see all the different features that we

implement. And the nice part about the documentation is these are interactive docs. So from the documentation, I can actually send HTTP requests to my application and get a response back. So you

can really see all of the different features, things like the authentication and the crowd operations that we'll be performing and setting up in our API. So the app that we're going to

build for this course is going to be a social media type application where users can create posts, they can read other people's posts, they'll be able to perform all the crowd operations. So

they're able to create, read, update, and delete posts. And we'll also be able to vote on posts.

So you know, most social media apps have some sort of like system or voting system. And so we will

be able to like other users posts as well. So this is the built in documentation that comes with fast

API. And you'll be able to see all of the API endpoints that we're going to create in this course. So we're going to have all of the posts endpoint, which is going to be responsible for retrieving

all posts, creating posts, retrieving an individual post, updating a post as well as deleting a post.

Then we'll have the user specific endpoints of things like creating a user getting a user's information. And then we've got our authentication, which is going to be used for logging in. And then

finally, we've got the one for voting. So when you want to vote on a specific, a specific post that

you like, you can go ahead and like that post. So let's just use the documentation to actually,

you know, test out our API. So first things first, let's actually try to retrieve any or all of our

posts. So if I hit this Get button right here, we can actually try to send a request to our API with the built in documentation. So you can just say execute, right, and you'll see that we got a

401, which means that we are right now not logged in. So we are unauthorized to retrieve any of the

posts. So the API that we're going to build is going to require all users to be logged in to be to even be able to read the posts. So let's actually go ahead and create a user. And so

we'll go down to the user's endpoint under Create user. And I'm going to do try it out. And it's

going to give us an example of the structure of the data that we have to send to our API to create a user. So we need to provide a username or an email and a password.

So I'm going to create an email, I'll call this john at gmail.com. And the password is going to

be something simple, just for demonstration purposes. And we'll execute that, right? So it'll

actually send that data back to our back end, you can see we get a 201, which means we were successfully able to create it, you can see the ID of the user account that was created, we can see the email is

what it is, and then we can see the date that it was created at as well. And so now we can actually log in as this user. So there's a couple of different ways to log in, I can go to the login

endpoint, or we can just go up here at the top and just do authorize. And then we can provide that information. So I'll do john at gmail.com. And we'll provide his password. And if we do

authorize now, we can see that we have successfully logged in. So I'll close this out. And so now if

I try to retrieve the posts, and then hit execute, you can see that we were able to retrieve all of

the posts in our database right now, there's only two. But you can see that these were created by some other users like Sanjeev in this case, and then Sanjeev 123. And if we want to create our

own posts, we can go ahead and do that. So I'll go to the create post endpoint. And we'll do try it

out. And it's going to give us an example here. So we have to provide title content, as well as is this post going to be published, or is it going to be a draft. And you'll actually see the structure

of this schema right down here. I think it's at the bottom, actually. So if you go to post,

create here, this is going to show us the the schema that we have to pass, we have to provide a title content. So the asterisk means it's required, the published is not required. And

you can see that it defaults to true. So if we don't provide a value, it'll default to true. So let's test that out. And so I'll just say favorite foods is going to be the title.

And the content is going to be pizza and burgers. And I will remove the published

section because it is optional and no default to true anyways. And we'll hit execute. And if we

take a look at the response, we get a 201, which means it successfully created it. And you can see what the post looks like in our database. You've got the title content, we can see the published

got defaulted to true, we could see the ID of the post when it was created, we could see the owner

ID, which is, you know, who created the post. And so that's the idea of our account, which is 17. And we can see the information about the owner. So this is john at gmail.com.

And then, you know, as usual, we could perform all the other CRUD operations. So we can retrieve an individual post, update it and delete it. And then once again, if we go down here, we can also

vote to like a post as well. And so, you know, this kind of forms the backbone of a traditional

social media type application. So once you can really do this, you can really create any application you want. And I think this covers enough things from an API perspective, as well

as from a SQL and database perspective, that you will have a solid foundation to really build out any API that you're interested in building out. And so I think that's enough talking, let's get to

actually start coding out our application. In this video, we'll take a look at how to set up Python,

as well as VS code on a Mac machine. The first thing we're going to do is we're going to just search for Python. And the first result should take us to the main Python page. And what we want

to do is like downloads, it's automatically going to give us a button to download whatever the latest version of Python is. And the nice part is it automatically detect what platform you're using,

so it'll know that we're on a Mac. And right now, it says that the latest version of 3.9.6. So it's going to offer me that keep in mind, if you're watching this video in the future, it's going to

show a different version. And it's okay for you to download a newer version, as long as it's later than 3.7, you should be okay for this course. So I'm going to select this and it's going to download

it like any other application. Once it's finished downloading, we're gonna select that and then select the file that we just downloaded. And then this is going to take us through the Python

installation process. So we'll hit Continue, we'll hit Continue again, continue. We'll hit Agree,

and then install. And then it's going to prompt us for a password.

Alright, and so once you get this pop up, it means that Python was successfully installed. So we can then close that out real quick. And then we can move this to trash. And the next thing

that we want to do is go up to your search bar at the top. And I want you to search for the terminal

application. And you should find that just double click on that. So we can open up a terminal.

And with our terminal, what we want to do is we want to type in Python, three, dash, dash version.

And the reason we specify Python three is that you can actually have a Python two and a Python

three version simultaneously installed simultaneously on your machine, we want to make sure that we got Python three successfully installed. So if we type this in, it should then print out the version that

we installed. So we can see that we did successfully install Python three dot nine dot six. So we should be set from a Python perspective. And now that we have Python installed, let's go ahead and install

VS code. So like I said, VS code is going to act as our text editor or ID. And so what we're going

to do is just search for VS code. And this is going to take us to the Microsoft page. And then

once again, Microsoft will automatically detect that we're running a Mac. And then we could just go ahead and select download Mac universal. Alright, and once that's done installing or

downloading, we can select that and open it up. And you'll get this warning, just go ahead and

select open. And so this is going to open up our VS code. And what we need to do is VS code is just

a very basic text editor. However, it comes with extensions that we can install that make it

significantly more feature rich. So it'll almost act like a traditional ID. And if you select the

extension icon, which is this icon right here with the extra blocks, select that and I want you to search for Python. And the first result should be the one you want and it should be the one that's

made by Microsoft. So this is going to provide things like linting, IntelliSense debugging and a few other features that are going to come in handy when it comes to writing Python code within

VS code. So go ahead and install this. Alright, so now that it's installed, what we want to do is

select this icon to go back to our folder menu. And we want to select open folder. So what we're going to do is we're going to create a folder to store all of our project code, I'm going to select

open folder. Now we haven't created a folder to actually store our application. So I'm going to

go under my traditional users, Sanjeev, and then I'm just going to store this within my documents,

I'm going to make a new folder called, I'll call this, we'll just call this fast API.

Well, create that and then we're going to open up the fast API folder that we just created.

And so this is going to open up all of our project code. Right now we have no files, and that's to be expected. But what I want to do is I want to right click here and select new file.

And we want to do is type in main.py. And before we hit enter, I want you to look down here.

But when I hit enter, you'll see that something's happening. So it's activating the Python extension. And it's automatically going to selected Python interpreter. And so like I said,

you can have multiple different versions of Python. So technically, we could, you know, for any one of our projects, we can be running three dot nine dot six, or maybe we're running

two dot seven, if we want to stick to Python two, we can actually select which specific Python interpreter we want to run on a per project basis. And if you ever want to change this,

or for some reason, it wasn't able to find this correctly, just go ahead and select view, command palette. And then it automatically found the most recently used ones, but you would just

search for Python, select interpreter, select this. And it shows the currently selected interpreter,

but you can also enter in the path to find a specific interpreter. So you would just find wherever Python two dot seven was installed. If you wanted to use that, or if it was unable to

find three dot nine dot six, go ahead and just find where Python three dot nine to six was installed on your machine and point to that Python dot exe file. Actually, it's not called dot exe

within Mac, I forget what it's called on a Mac, I actually use a Windows machine for most of my things. But that's all you have to do. And so at this point, we've got Python setup. And then we've

got our VS code setup. So once again, anytime VS code closes, you want to open it back up and then

open up the folder fast API in this case. In this video, I'm going to walk you through setting up

Python as well as VS code on a Windows machine. So the first thing that we're going to do is within

your web browser, just search for Python. And then we're going to select the first result. So this is going to take us to the main Python page, we want to go to the download section.

And so here, Python, the website's going to offer you up whatever the latest version of Python is. In this case, it happens to be three dot nine dot six. Keep in mind, if you're watching this video

in the future, it's going to show some other version. And that's okay, go ahead and just download the latest version. As long as it's a later than three dot seven, you should be okay.

So I'm going to just hit download Python three dot nine at six. I'm going to download that once it's finished downloading, I'm going to select that and it's going to open up the installer.

Now with this installer open, it's very important that you select add Python three dot nine to

path. Do not forget to do this, or then you're going to run into some issues. So make sure that's selected and then hit install. Now, if you go through the installation process, and you realize

you forgot to do this, technically, there's a way to fix it afterwards. But instead of me explaining to do that, the best thing to do is just uninstall Python and reinstall it. So hit install. Now,

you'll get a pop up, just go ahead and hit Yes. All right. And once you see this message where it says set up was successful, that means Python was installed. And the next thing that we want to

do is just quickly verify that Python is up and running and working. So what we're gonna do is we're just going to search for CMD. So it's going to open up our command prompt or terminal. And

then in here, just type in Python, dash three, dash dash version. Sorry, we should actually type

in Python py dash three, dash dash version. Alright, and so when you type this command in,

it's going to tell us the specific version that we installed. So we can see that I was successfully installed Python three dot nine dot six. If you get any kind of error, or any message saying that

this command is not available, that means that Python wasn't installed successfully. So just go ahead and redo that process just in case. Now, the next thing that we want to do is install VS code.

So let's open up a new tab, just search for VS code. And then we'll select this is going to take

us to this page. And you'll see that VS code will automatically detect what version you're running. So you can just like download for Windows. And then once it's finished in downloading,

go ahead and open it up at the accept agreement at next, next, next, and then you can leave everything

as default. And then go ahead and run install. Alright, and then go ahead and finish it's going

to automatically open up VS code. Now there's a couple of things I want to do. So VS code at its

core is just a basic text editor. However, we can install extensions that give it extra functionality,

extra features that will make it operate a little bit more like a full blown ID. So go ahead and

select this icon right here. This is for extensions. And then what we want to do is we want to search for Python. And we usually just want to select the first one, it'll have a star and it's gonna be the

one made by Microsoft, you'll see that there's other ones made by other users, but we want the main Microsoft one, hit install. And so this extension is going to give us IntelliSense,

linting, debugging, and a few other features that are going to make it a little bit easier to start working with Python within VS code. Alright, and so now that it's done installing, we can just

close this, close this, and then select this one to get back to your main file browser. And right

now we haven't opened up any folder. So what we want to do is we want to create a folder to store all of our application code. So select open folder, and then figure out where you want to

store your application code. So I'm just gonna store this in my documents, you can store this wherever you want. I'm gonna create a new file or a new folder, I'm just gonna call it fast API.

But you can name your project whatever you want. So just select folder. And so that's going to not

have only create not only create the folder, but it's going to open it up within VS code. If you get this error, just select Trust the author, and just like yes. And then we can close out this

welcome menu. And so now what we have is we've opened up whoops, we've opened up VS code. And

within VS code, we've opened up our project code. So right now there's no code that's to be expected. But what I want to do is I want to create a new file real quick, just for testing purposes.

So I'm just gonna right click hit new file, and I'm going to name it name main.py.

And so we want to name it.py, because there's gonna be a Python file. And before I hit enter, I want you to focus your eyes right down here. And you'll notice something happens down there.

So when I hit enter, you'll see activating extension. So it's activating the Python extension. And what the Python extension is going to do is it's automatically going to select the correct

Python interpreter, or it may not be correct, depending on what happens on your machine. For me, it automatically detected Python three dot nine dot six was installed on the machine. So

let's selected that one for me. Keep in mind, if you have multiple versions of Python installed, it may select the wrong interpreter. So what you can do is if you ever want to change the

interpreter or specify a specific interpreter, go to view command palette. And what I want you to

do is search for Python interpreter, and then look for a Python select interpreter. So right now,

it's going to highlight where the current Python interpreters which one selected and what's the executable for it. But if you want to change that you can select enter interpreter path and then

provide the path to the specific version that you want. So you can always change it. But usually it's able to detect the latest version. So you should be good to go. And so that's all I wanted

to do from a setup perspective. There's one more thing that we'll cover later. But we'll get to that in the next section. But right now we've got Python installed and we've got VS code set up.

And we've got our project directory setup, so we should be good to go. So now that we have Python

and VS code setup, the next thing that we have to do is set up our virtual environment. Before we do that, we have to actually talk about what our virtual environments and what problem do they try

to address. So let me give you a little bit of an example scenario of the issue that we can run

into when working with specific packages within Python on your local machine. So let's say that

we created a project and this project is called project one. And what we need to do is we need to install fast API version one dot two dot one. So what do we do, we install version one dot two

dot one on our machine so that we can actually use that version. Now let's say later down the road,

we start a new project called project two. And let's say this version requires us to run fast

API version two dot four dot three, because we want to try out some of the newer features. Well, at this point, if we need to try out a newer version, we have to upgrade fast API to version

two dot four dot three on our local machine. And this may or may not be a problem, it really just depends on if version two dot four dot three is backwards compatible with version one dot two dot

one. Because if version two dot four dot three has breaking changes, then ultimately, that's going

to create issues with our project one because that project expects us to run version one dot two dot one. And so if we can upgrade, well, we're in a little bit of a pickle because one project needs

one version, the other project needs another version, we can have two different versions installed on our machine. So what exactly do we do? Well, this is where virtual environments come

into play. So with virtual environments, let's say we want to create a project. So we create

project one. And what we do is we create a virtual environment, call it whatever you want. And so this is a isolated environment that will not affect any other environments. And within this environment,

we can install any Python packages running whatever version we want. And it's completely isolated to

this project. And so when we create a second project, what we can do is we can create its very own virtual environment as well, we'll call it virtual environment two. And within this virtual

environment, we can install any version of any package that we want. So then we can install version two dot four dot three. And so both of these virtual environments are completely separated,

completely isolated with one another. And so we can essentially install multiple different versions of a single package for each of our projects. And that way, our projects don't end up stepping on

the toes of other projects. And so now that we have a basic understanding of virtual environments, let's go ahead and figure out how we can actually create our first virtual environment and use it

within our project. In this video, I'm going to walk you through setting up a virtual environment

on a Windows machine. Now, if you already close out your VS code window, go ahead and open up a new one and make sure you open up the specific directory we created a couple lessons ago. Now,

what we want to do is we want to select terminal, and we want to select new terminal. And this is a awesome feature with VS code, it allows us to have a integrated terminal within our VS code

window. And this terminal is fundamentally no different than a regular terminal within Windows, it's just built into VS code so that we don't have to keep flipping between different windows.

And if you actually take a look at this right column, we can have multiple terminals open and we can even use different terminals. So the default one on this machine happens to be PowerShell.

But you can also use command prompt if that's what you prefer. So if you select command prompt, it's going to create a new terminal. And you can see that this is a traditional command prompt,

I'm going to use this one because that's the one I normally use. However, if you're more comfortable with PowerShell, feel free to use that. Now the command to actually create a virtual environment

within Windows is p y dash three dash m b n v. So that stands for virtual environment. And then you

want to give it a name. So give whatever name you want for your virtual environment, you can name it after your project name, or you could just do what I do, which is just call it V and V. And what I

like to do is for all of my projects, I give it the same exact name. And that's perfectly okay, because this virtual environment is going to be isolated to this project directory. And so even

though this project has a virtual environment in V and V, I can create another virtual environment in any other project with the same exact name, they're all going to be isolated to that specific

project folder. So go ahead and hit enter. And take a look over here, you'll see that a folder

was created called via virtual environment or V and V. And that's going to be the name of this

folder is always going to refer to whatever name you gave it. So if I named this cookies, this would open up a new folder called cookies. And if you want, you can take a look at what's

in here. And if you go under scripts specifically, you'll notice that we've got our Python executable. So this is going to act as our new interpreter. And so what we want to do is right now we are

using our global interpreter. And we want to change that we don't want to use the global one,

we want to use the specific one in our virtual environment. And that way we can install packages

that are exclusive to just this specific virtual environment. And so to do that, go ahead and select view once again. And we want to go to command palette, and then search for Python

select interpreter, as usual. And then you'll see the one we're currently using, but we want to pass

in our newest one. So select enter interpreter path. And then we want to give it the path to

our interpreter, which is the path from the root of our project directory to this Python dot exe

file, we're going to say dot, which is our current folder. So this is going to be the fast API folder.

And then within here, we want to go into scripts. And then within scripts, well, sorry, we want to

go into the virtual envy folder, then scripts, and then Python dot exe, go ahead and hit enter.

And then if you look down here, you'll see that this gets updated. So now we're still using three dot nine dot six, but we're using our virtual environment. And so that's all we need to do.

And it should remember this every time we open up our project, however, double check every time you

open up just to make sure you're using that if it's for some reason moved back to the default one, just do the same process. Now, the second thing that we need to do is we need to make sure our

terminal is also using the virtual environment. And so what we want to do to do that is just type in

the path to this specific activate dot bat file, this is going to activate that virtual environment

within our command line as well. So I'm going to say virtual envy. And then we want to pass in

our scripts folder, and then activate dot that hit enter. And then notice what's changed, right.

So when you're using a virtual environment, right, you're going to see the name of the virtual environment to the side of it. So always double check whenever you start up VS code, and you start

up your project, that this is enabled, if you don't see this, then just run the same exact command. And that's going to reactivate the virtual environment. And so at this point, we are good

to go with our virtual environment. And we can start coding out our project. In this video,

I'm going to walk you through setting up a virtual environment on a Mac machine. Now, if you've already closed out your VS code window, go ahead and open it back up and open up the

folder that we created a couple lessons ago. And within here, what we want to do is we want to

access our terminal. So we can access our terminal just by selecting this. And then this is our terminal. However, VS code has a feature where we can access the terminal directly within our VS

code window. So if we select terminal and the new terminal, that's going to create a new terminal for us. All right. And so this is fundamentally the same thing as this terminal right here,

it's no different. But at least by having it built into VS code, we don't have to keep flipping back and forth between the two. So you can use either one, whichever your preferences,

keep in mind that when you open up the terminal within VS code, it automatically moves you to the the directory folder of your project. So you don't have to move there yourself.

You can use whichever one you want. Now, I'm actually using I'm running Mac on a virtual machine right now, just because I natively use a Windows machine. So I don't actually own a Mac.

So this is a little bit buggy. And if you see me type things, you can see it vanish. So for demonstration purposes, I'm just going to use the regular terminal, but I strongly recommend you use

the one built into VS code. So you don't have to keep flipping back and forth. Now to actually

create a virtual environment, there's a one command that we have to run. So you run Python,

three dash M, V, N, V for virtual environment, and then you have to give it a name. So what name do

you want to give your virtual environment? You can technically give it any name you want. You can name it after your project, you can give it some arbitrary name. What I like to do is I like to

name all of my virtual environments, V, N, V. And so for every project that I create, I just create

the same exact virtual environment name, V, N, V. And that's not going to create an issue. It's perfectly okay to name all of your virtual environments the same thing, because it's all

going to be exclusive to this specific project folder. So no other projects can access it. So it's okay, if they all use the same name, it's just easier. And so that way, you know, if I ever

create a get ignore file, I can automatically add V, N, V. And I can make sure to just use the same

exact get ignore template across all of my Python projects. So I'm going to use V, N, V. And I want

to make sure that you pay attention right here. Because after I run this command, take a look at what happens. It creates a folder called V, N, V. And that's based off of the name of the virtual

environment. And if we take a look at our virtual environment, you can see a couple of different files, you can see the, the Python file as well. So if you go under bin, this is going to be the

new Python file or the Python three file that we're going to use for our interpreter. So down here

at the bottom, you'll see that we are still using the global interpreter, we no longer want to use the global one, we want to use the one in our virtual environment. That way, we don't, you know,

cause any issues with other projects, we want to use the virtual environment. So to do that, what we want to do is we want to select a view, command palette. And then we want to do the

Python select interpreter again. So we'll select that. Right. And so right now, it shows us that

we are using the global one, however, we're going to pass in the path to our specific interpreter

within our virtual environment. So we'll select enter interpreter path. We'll say dot for current

directory. And so that's going to mean the current fast API directory, then within there, we want to

go into the virtual environment folder. And then within there, we want to go into bin. And then

just say Python. And so we'll hit enter. And then take a look at what happens down here.

Right, you notice that the version still says three dot nine dot six, but our interpreter is actually pointing to our local virtual environment now, because we changed the interpreter to use

this specific Python file right here. And so this is what's going to allow us to install our own

specific fast API version, as well as any other version of any package that we want. So it doesn't actually install it globally on our machine. Now, we're almost done. But there's one other thing to

note. If you look at our terminal, our terminal isn't using our virtual environment. So if I run pip install any package, it's not going to install it for a specific virtual environment, it's going

to install globally. So we have to enable the virtual environment for the command line as well.

And to do that, all you have to do is type in source. And then we want to pass in the path to

this specific activate file right here within bin. So we do the env slash bin slash activate,

hit enter. And then notice how our command line changes. Now it's prepended by the name of our

virtual environment. So since we named it v env, you can see that it shows it right before the terminal. And so that's all you have to do. Our virtual environment is set up, keep in mind,

if you close out your terminal, and then reopen it, you'll notice that your virtual environment

is gone. So you have to run that same exact command every time you open up your terminal to ensure that you are in your virtual environment. And anytime you close out VS code, make sure that

when you reopen your project, it still points to the virtual environment. If for some reason it changes, then just go back to that command palette, by going to view command palette, and then

selecting the interpreter that you specifically want. But that's all we have to do guys. So our virtual environment set up. And so at this point, we can go ahead and get started on coding out our

project. But now that we got our environment set up, it's time to get started coding out

our project. And what I want you guys to do is first of all, go to the fast API documentation,

this is really important. What I want you guys to do is really get a solid understanding of how the documentation works. So pull up the fast API website, and then head on over to the tutorial

section and then select the intro part. So this is going to walk us through setting up our project. And what we will need to do is first of all, we need to install the fast API package. And so what

we can do is we can either do pip install fast API, or we can do pip install fast API, all when we do

pip install fast API, all it's going to install all of the optional dependencies as well, which we may or may not need depending on what features we want, we're going to go ahead and use the all

option because we're going to use a lot of them. And there's no point in having to go one by one and install them. So that's what we're going to do. So here, in our command line, and make sure that

we are in our virtual environment, and then just type in pip install fast API. And then we'll pass

in all and we'll let that run. Now it's moving fairly fast. But if you kind of scroll through

the history, you'll notice a lot of packages, and a lot of dependencies that are getting installed. So we'll take a look at those once it's done, just to see what are the different dependencies

that were installed. And so now that that's done, if we type in pip freeze, this is going to show

all of the packages that were installed. So it's not going to be just fast API, it's going to include a lot of the optional dependencies as well. So if we take a look, you can see that we've got

graph ql installed, if we want to use any graph ql, we have B crypt UV coin, that's going to be

like our web server web sockets, we want to work with web sockets. So it already comes bundled with a lot of things that we're going to use. And I just wanted to make sure that you guys understood

what's happening when we pass in the that all flag. And if you want to, if you open up your virtual environment folder, and you go under lib, you'll see all of the the code associated

with those packages that we installed. So that's where all of them are going to reside, they're all going to reside within the lib folder. Alright, so now that we've got fast API installed,

the first thing that we have to do is we have to import fast API. And to import fast API, we just say from fast API, which is the name of the library, we import fast API.

Alright, so we've now successfully imported fast API, let's create an instance of fast API. So

we'll say app equals fast API. And then we'll call that function. Keep in mind, you can name

this anything you want. But if you take a look at the documentation, and just follow along, you can see that it's going to name an app. So I think it's best if we just kind of follow along

with that convention, then what we're going to do is we're going to just copy this code right here. So this is going to be what's referred to as a path operation. And we'll go over what that means

in a bit. And we'll just paste this here. I want you to save your code, you'll see if you get this

warning or this message saying format or auto pep eight is not installed, go ahead and hit yes.

And so this is nice, because it will automatically format our code. So if we ever put too many spaces or things like that, you'll see that as soon as you save it, it's going to snap into place and make

everything look nice and pretty. So let's save this. And so once we've got our code, let's actually start our web server up. So how do we actually start our web server? Well, once again, let's

go to our documentation. So we're going to make use of the uvcoin library. So because we installed

fast API with the all flag, it automatically installed uvcoin. If you didn't use the all flag, then you'll have to do pip install uvcoin as well. But we already got it installed.

And so let's go back here. And let's run our API. So we do uvcoin. Then what we have to do is we

have to reference the name of our file. So this is their entry point into our application, which is our main file. So here, we're going to say main, keep in mind if this file was named anything

else, if you don't have to name it main, you can name it anything else, you would just want to pass the name of whatever the file name is, then you do colon, then you pass in the name of your fast

API instance. So we named it app. And so we'll do app. And then we'll start that. Right. And so this

is saying that we started our server. Perfect. And we could see the URL that our server is running on. So it's going to say HTTP colon slash slash 127 dot zero, zero to one. So if you guys don't

know what that address is, that means it's this machine. So whatever IP address, this machine runs on, that's what this is going to be. So it's just saying a we want to refer to the local host,

and it's going to run on port 8000. So if you want to, you could just copy this URL,

go to your web browser, paste it in here, and then see what happens. And then look at this,

I'm going to zoom in for you. It says message Hello World, and that's coming from our code.

Right. And that's coming from this return statement right here. So that so this kind of verifies that everything worked perfectly. Alright, so now that we've got everything up and running

and working, and you can see that when we go to our website, we can see that we are properly getting back our message. Let's pause this video. And in the next video, we'll take a look at exactly

what each line of this code actually means. Alright guys, so let's take a look at the code

that we added and actually dissect what each line means. So we've got these three lines of code. And if you take a look at the fast API documentation that we were on, it's going to define those three

lines of code as a path operation. So that's the terminology is using it refers to this as a path operation. Now, the name itself doesn't really matter. You'll see that in other web frameworks,

especially in other languages, sometimes they refer to this as a route. But they within the

documentation for fast API refer to as a path operation. So you'll see me flip between those two terms, but they fundamentally mean the same thing. So let's actually take a look at this

specific path operation. And we can really see that it's made up of two components. The first component is going to be the function. And the second thing is going to be the decorator. So

we'll come back to the decorator in a bit. Let's take a look at this function. So this function is fundamentally no different than any other Python function. It's a plain old function,

you'll see that there's this async keyword, technically, this is optional. This keywords only needed if you're going to be performing some sort of asynchronous tasks, so something that

takes a certain amount of time. So things like, you know, making an API call, things like talking to the database, if you want to do that asynchronously, you do have to pass in the async keyword.

But we're not doing that right now. So what we can do is we can actually just remove that. So I'm going to delete that, and just remove that. And so now it's just a regular function. And you'll see

that the code behaves exactly the same. So we have a function, we give the function a name. So

the documentation just shows an arbitrary name of root, keep in mind the name itself doesn't matter. So if I wanted to name this, you know, get user, then that's going to be fine, it's not going to

change anything, it's an arbitrary name. However, I do recommend you name your functions, your path

operation functions to be as descriptive as possible. So if you're trying to log in a user,

then maybe you should call this login user, or just log in so that it's as descriptive as possible.

But keep in mind, the name that we put here does not matter. So I'll change this back to root for now. And then we have so then within this function, you can perform any kind of logic. So if this

function is meant to log in a user, it's going to have all the code for logging in a user, whatever that may be. So maybe you know, checking the passwords in a database to make sure that

they match and to make sure that the credentials are properly accurate. And then after that,

you know, just like any other function, we can return something. So whatever we return here is going to be the data that gets sent back to the user. So if we go back to the website, go to our

web server, take a look at this message, Hello, world, that's exactly what we sent. And if we change this to be whatever we want, it's going to get returned back in the same way. So here,

we're just returning a Python dictionary, I guess. And what happens is, fast API will automatically

convert this to JSON, which is the main universal language of API, right? We all talk to we use

JSONs to send data back and forth between an API. So it converts this JSON, and it sends it back to

the user. And that's why we see that on the web browser. Now, the next thing that we have is this

decorator, if you're not really familiar with decorators in Python, it's okay, you don't really actually need to understand, you know, the core concept of a decorator, just understand that when

you apply a decorator to a function, it's going to perform a little magic to this function. Because if I remove this decorator, if we just comment it out, take a look at this code, this code has

nothing to do with fast API, it's a plain old function. So how do we actually make it, you know, act like an API? Well, we have to use this magical decorator, this decorator turns this into an

actual path operation, so that someone who wants to use our API can hit this endpoint. And so you

just specify at the at symbol, that's what the that's how we clarify that this is going to be a decorator, then we reference our fast API instance. And then we have a couple of different options.

So what here we pass in is the HTTP method that the user should use. So this is a get method,

which means that we have to send a get request to our API. And, but we can use plenty of different

HTTP methods. And I strongly recommend you actually take a look at the different HTTP methods. If you

do HTTP methods, we can select this one, this is the Mozilla page, you can see all of the different

HTTP methods. So there's get, post, put, delete. So those are the main ones. There's a couple of

other ones that are sometimes used. But for the most part, those are the core ones. And so here,

once again, just the HTTP method. And then finally, we have the path. And so this is the root path.

And so, and so it's a little bit hard to explain the path, but it's basically the path after the

specific domain name of your API. So if you take a look at our, our URL, our web server is hosted

on this specific URL. If I go to this page, let's open up a new link, just paste it in here. So,

so the URL and the path in this case is just slash. So that's equivalent of just hitting enter right here, or putting a slash, which doesn't change anything, right? Right, whether

there's slashes there or not, it's basically going to take you to the same URL. It's very similar to going to, you know, google.com. Right, that's going to take us to google.com. But if you go

to google.com slash, it's, it's the same thing. So it's the root path. So whatever domain name,

our API is hosted on, whatever URL is just saying it's the root path. You know, if I change this to,

you know, log in, right, that means that this path operation will only apply if the user

goes to our URL, and then goes to slash login. So that decorator, this path right here just

references the path that we have to go to in the URL. And so if this is actually changed to,

how about posts, and then you know, like vote, so maybe this is the URL for voting on a specific

post, then we would have to go and do the same thing here. So we'd have to go to post slash

vote. So nothing too complicated. But those are the two pieces that make up a simple path operation,

you've got the function, then you've got this decorator, where you have to pass in the specific HTTP method, and then the URL you want it to go to. And I'm going to change this back to the default.

And now what I want to do is, let's go ahead and make a simple change. So what I'm going to do is I'm going to change this, I'm going to change the message to be welcome to my API, we'll save this,

go back to the root URL, because we changed it to the root URL. Let's hit refresh. Notice how it still says Hello, world, nothing changed. So what gives, right,

it, you know, our codes changed, I saved it, why are we not updating it so that it returns welcome to my API? Well, the problem is, is that anytime you make a change, we have to restart our server.

So to restart our server, you hit Ctrl C, which is going to stop it, then you could just hit the up arrow keys that you can find that command that you ran before, and just run it again. And so now

if I hit refresh, we can see that it updated. And I'm sure you're thinking, well, that's a little annoying. Every time I change my code, I have to do a Ctrl C, and then an up arrow and then hit

Enter, just that I can, you know, make sure that the server actually implements those changes. And it is a little annoying, but there is a workaround. So if we go to the documentation,

you'll see that when they run uvcorn, they pass in the dash dash reload flag. And the dash dash reload flag will actually take a look at your code and monitor your code. So anytime that you change

your code, it'll automatically restart your server for you. So let's try that out. I'm going to do a Ctrl C. I'm going to hit the up arrow, and I'm gonna pass in the dash dash reload flag. So we'll

hit enter. And now what I want you to do is make some changes. So it doesn't really matter what you

change, I'm just gonna add a couple of exclamation points. And then I'm going to hit save. And I want you to focus what on what happens down here. So if I hit save, look at that, it automatically

restarted the server for me. And so now if I go back to my website, or my API, hit refresh, you can

see that the exclamation points are there. So moving forward, in a development environment, only when we're in a development environment, we're going to pass in the dash dash reload flag.

When we go to production, we don't need that, we're not going to be setting it up because we're not going to be changing our code in a production environment. And so I think that's a good

stopping point here. In the next video, we'll just quickly review exactly what is a path operation,

so that we could just reinforce what we learned in this lecture. All right, guys, so let's quickly

recap what we learned in the previous lecture, I want to make sure that you guys have a solid understanding of the different components of a path operation, because ultimately, that's all your

API is, it's just a bunch of path operations. So first things first, we have our decorator. So our

decorator has the little at symbol. And so that's what signifies it as a decorator. And then we

reference our fast API instance, which we called app. And then we have our HTTP method. So in this

case, this is going to match only get methods. And then we have the specific path or the URL. So this

is the root URL in this case. And then below that we've got our specific path operation function. So

this function is going to contain all the logic for performing some kind of task. And when it's going to return some data, and that's the data that gets returned to the user when they hit this

specific path operation. So now that we have a solid understanding of how path operations work,

let's see if we can create a new path operation. And let's say this one represents retrieving a bunch of social media posts from our application. So in this case, you know, there's two things that

we need. So the first thing is our function, our path operation function. So we'll say def. And then we'll give this function any name, I think, since we're going to be retrieving a bunch of

posts, I think a good name is going to be get underscore posts. But keep in mind, you can name

this anything you want. Like I said, it does not impact the behavior of anything. And then we want

to see. So here we would pass in all of our logic for retrieving posts, but we don't actually have an application. So I'm just gonna say return. And then we'll just say, maybe, I don't know, data.

And this is going to be, this is your post, but in reality, we would provide a list of posts. So

let's save that. And then there's one last thing we have to pass in our decorator, like we did before to actually make this turn into a special path operation function. So we'll say at and we

reference the instance, the fast API instance, we'll do app dot, and then we have to figure out

what HTTP method we want to use for this path operation. So when it comes to retrieving data,

you usually use a get operation. And if you don't know which one to use, you can just go back to

this page right here, and it's going to explain what each one's for. So if you select get, it's going to explain when you would use a get, if you want to use a post, it's going to explain when

you should use post. But I already know that for retrieving data, it's usually a get operation. So

we're going to keep it as a get method. Now for the URL, I'm going to say, to retrieve a post,

we want to go to the slash posts URL. So we'll save this. And then let's see if we can retrieve

that data. So if I hit refresh here, it's going to say Hello World. But that's because if you take

a look at this, we're at the root path. And that's going to match this specific path operation.

And this path operations on slash posts. So if we go to slash posts,

and then hit enter, take a look at that, we have now got our data, which is our posts. So we have

hit that second path operation that we just created. And it really is as simple as that you just define a function, you define the HTTP method, and then the URL. Now there's one thing to know,

and that is that, you know, the way that fast API works is that when anytime we send a request to

our API server, it's going to actually go down the list of all of our path operations. And then

it's going to find the first match. And as soon as it finds the first match, it's going to stop running your code. So if I actually change this to just the slash URL, just like this one above,

what do you think is going to happen, right? They both reference the get method, and they both reference the same URL. So which one do you think is going to win? Well, let's take a look.

If I do just the slash again, it says Hello World. So it looks like the first one, one. And the

reason for that is that once again, fast API literally just goes to the code, and it looks for the first match. So there's really only two criteria. In this case, what's the HTTP method,

it's a get. So anytime you work in your browser, your browser is always going to send a get method by default. And then what's the URL. So the URL is a slash URL. So it matches this one. And it does

not continue past that. So it never runs this code. So it sends that back. Now, if I took this,

copied it, and moved it to the top. What do you think is going to happen? Which one do you think

is going to run? Well, let's hit refresh. Look at that. So that one ran. So the first path operation

that matches is always going to be the one that runs simple as that. So the order does in fact matter. However, if I change this to posts, and leave this at the top, right, if I hit refresh,

we get Hello World. So what happened was fast API went down the list. And it received a request

that let me just put some comments. So the rec request comes in. Sorry, that's not the way to

comment in Python. request comes in with a get method. And it comes in with the, the URL is going

to be slash. All right. And so these are the two things that it looks forward to match. So it hits

the first path operation. So this is a get so those two match, and then it looks at the URL, which is slash, but that does not match. So it skips past with this one. And then it goes to the

next one, you know, does, and then checks to see if that matches. So then get matches, the URL

matches. So then it returns Hello World. And that's why you return Hello World. And the reason I wanted to highlight this is that the order in fact, does matter. So you have to keep that in mind. And

it can impact the way your API ultimately works. I'm going to just take this move this to the bottom.

But in this case, the order doesn't matter because they're hitting two different paths or two

different URLs. Till now, we've been using our web browser to generate HTTP requests to test our API.

And that's fine for now. However, once we start getting into more complex path operations and

routes, so things that involve having to send a HTTP point or patch, or any of the other methods

and having to send data to our API, it gets very complicated, because there's no way to natively do that in the browser, without generating or building out a complete full front end application.

And to test an API, you shouldn't have to build an entire front end application to do that, that would be, you know, unmanageable, unscalable. And so there's a lot of different tools that we

have, that we can use to test our API. And so one of these tools is called postman. If you go to

postman.com slash downloads, you can download this app. So go ahead and just hit the download button, it's going to automatically detect what your operating system is. But this is a very

simple tool. It's just a tool that allows us to construct our own HTTP request. So we get to specify the individual fields of an HTTP request. So we could specify, you know, what is the HTTP

method? What's the URL? What are the headers that we're going to apply? What's the body? What kind of data is that going to carry? Is it going to have any authorization headers? So all of these

things we get to construct in a nice GUI so that we can test our API. So go ahead and download this.

Now I've already got it downloaded. But once you've got it downloaded, open up the desktop application. And you should see something like this, right? Everything should be relatively

empty. And what we want to do is, if we want to create a new HTTP request, all we have to do is

hit the plus button. And before I do that, what I'm going to do is, let's change this to dark

theme. So themes, I think this looks a little bit better. Yeah, that looks a lot better. And I'm

also going to zoom in for you guys. Let's make it a little bit more. There you go. Hopefully,

that's nice and easy for you guys to see now. So what we want to do is let's create a new HTTP request. So hit this plus button. And you can see that this provides us all of the fields that we

need to actually create an HTTP request. So the first thing that we need to do is specify what's the HTTP method. So if we go back to our code, right, we only have get requests. So whether we

want to hit either one of these path operations, it's going to have to be a get request. So we're

going to leave it as get but you can see we have all the other whoops, we have all of the other options. Then we have to specify the URL. So this is no different than the URL that we went to in

our browser. We just copy this URL. And we actually need the HTTP in there as well probably. So if we

actually go back to our server, and see where we started it, and actually the best way to get the

URL is just to stop it, start it. And then that's going to give us the URL. So we just needed the

HTTP beforehand. And then we just paste that in there. Okay, and so if I leave this as the,

you know, the root path, whether I include the slash, it doesn't really matter, actually, I can just hit send. And you look at this, this is the result that we got back from our API server.

So it says message Hello, world. And once again, you guys already know where that came from. And

that came from this specific return statement. And so you can see that this is so much easier

than using a web browser. Well, you guys may not notice how easy it is at this point. But once we get to constructing more complex path operations, you'll see that it's so much easier to use a

tool like this. And keep in mind, this isn't the only tool that does this, there are plenty of other applications that also do this, this is just the one that I'm familiar with, and the one that

I use, but I don't want to, you know, force any specific application down your throat, you guys can use whichever one you want. So if you already use one that you prefer, feel free to stick with

it. But before we wrap up this video, let's just test out our other specific path. So this one's

going to reside on slash posts, we're going to try that and we'll do slash posts. We'll hit send.

And look at that, we got our data that says this is your posts. So now we were successfully able to test both of our path operations using postman. And moving forward for the rest of this course,

we're no longer going to use the web browser, we're going to use postman to test out our API.

Till now, we've only been working with get requests. So all of the HTTP requests we've

sent to our API, all have been get requests. And so now we're going to learn about post requests,

they're a little bit different. And I want to kind of highlight what makes post requests different than get requests. Now, we're going to compare the two right now. And I've drawn out a little

diagram for us. So at the left side, we've got our web browser, or it could be our mobile device,

depending on whatever the front end is. And on the right side, we've got our API server. So this is our fast API server. Now, what they get requests, what we do is we just send an HTTP get requests.

And then we send that to our API server. And then our API server sends back some kind of data depending on what they're trying to get. So if they're trying to get a whole bunch of posts,

we send back the posts. Now with a post request, it's going to be similar, except there's one

minor difference. And that is that with a post request, we can send data to the API server.

So in this case, a lot of times what you'd use a post request for is for creating things. So if I want to create a post, I would, when I say post, I mean, like a social media post, not post as in

post request. But if I wanted to create a social media post, I would send an HTTP post request.

And I would include all of the data needed to create a post on my API server. So we'll send

that data over to the API server. And the API server will send back whatever data it thinks it needs to send. And so in real life, if we were trying to create a post, you we would include

whatever data we needed for posts. So in this case, we would include what's the title of the post, what's the content of the post, what's the user of the post, we send that to the API server,

the API server can then talk to whatever database to actually create the post. And then it can send back some data, you know, something like, hey, I've successfully created the post. And then here's

the final post after I created and then send that the send those details back to your web browser

or your mobile devices. So think of it like this, a get request is basically saying, Hey, API server,

give me some data. Whereas a post request is saying, hey, API server, here's some data, do whatever you need to do with it. So it's like, so it really controls the direction

of flow of data between the front end and the API server. So get requests are getting data from the

API server, whereas a post request is sending data to the API server. So now that we have a

basic understanding of how post requests work, let's go back to our code and see if we can create

a path operation for a post request. So let's go below our last path operation, which was forgetting

posts. And let's create one for creating posts. So first things first, let's, let's just actually create our decorator. First, we'll do app dot. And instead of guest, sorry, instead of get,

we're gonna say post. So that's all it takes to convert a traditional get request to a post request, you just say dot post. And then once again, we're gonna say whatever specific URL the

user should go to, to actually create the post. Now, I'm going to do something a little bit bad, I'm going to say the path that we want to go to is called create posts. And if you've ever worked

with API, this is kind of going against best practice. But don't worry, we'll correct this in the next lesson. Because there are certain best practices is not going to break our application by

any means. We'll say this, and then we'll say def. And then here, we'll just name our function, I'll just say create post, like I said, the name of the function never matters.

And then here, which all we're gonna do is we're going to return, we'll say message, oops, message.

And then we'll say successfully created posts. Let's save that. And let's go to our postman.

And so we've got already one request. So I could just change this to post. And then we have to

change the URL in this case. So we'll go back and see that create posts. So it's going to be a

create posts. And let's hit send. And let's see what happens. Look at that message successfully

created. So we have successfully sent a post request to our API. Now, one thing I like to do

with postman is that you can create multiple requests and then have them saved. So I'm going

to actually change this back to just go to posts. And then go to get and then we'll keep that. And

what we can do is we can just add another request. And so I'm just going to copy the URL here. I'm going to paste this. And then this is actually going to be create posts. And then this could be

a post request. And so now we can hit a get request and then hit a post request really

quickly, because they're essentially, we've got them in two different windows. And let's just

quickly double check that still works. That's good. And then let's double check get posts that still works perfect. Now, that's cool. And all, however, the whole idea behind a post request is

to send some data to our API server. So how do we do that? Well, let's go to our post requests.

And what we want to do is we want to send some data in the body of the request. And to do that,

within postman, you would go to the body section right here. And then we can do that. And then

within body, what we want to do is go to raw, and then select the type. And normally, when you're

working with API's, you want to use JSON, however, you can use a XML and a few others, however,

most people use JSON. So we'll select JSON. And then we'll do and JSON looks very, it operates

very similarly to a Python dictionary. So it's, you know, curly braces, and then it's going to be

a whole bunch of key value pairs. So here, I'll say, what's the title of my post? Well,

title, my post is going to be say, I will say, top beaches in Florida.

And then the content of the post is going to say, check out these awesome beaches, beaches.

All right. And so now, if we hit send, let's see what happens. Great. So it says successfully

create post, we successfully hit this endpoint. But in our path operation, how do we actually

extract the data that we sent in the body? How do we retrieve that body data? Well, what we can do

is within our path operation function, I can say, I can just assign it some variable. So what

variable do we want to store all that body data, you can pick any name you want. I'm just gonna say this represents payload, although it could be something like body or anything else. So we'll

say payload. And then what we want to do is colon. And then we want to say, it's going to be of a type

dict. And we want to set this equal to body. And we want to import this. So this is actually

something that comes from the fast API library. So if you do tab, if you hit tab, it's going to

automatically import it, or you can select it. So you hit body, and then do that, and then triple

dots. And just to keep in mind, right, if you see that from fast API params, it imported body. So

what this is going to do is, it's going to extract all of the fields from the body, it's going to

basically convert it to a Python dictionary. And it's going to store it inside a variable named

payload. Pretty simple. And all we have to do is let's say print. Let's just print out payload.

Now if we hit that post request, again, look at this, right here, we can see that it converted

into a Python dictionary, and we extracted the title field, as well as the content field. And

so that's how we extract the data from the body of the payload. And just to quickly recap, once again,

we imported body from fast API dot params. And we let VS code do it automatically for us,

I always recommend letting VS code do it for you, so that you don't have to memorize. And remember,

you know, where in the fast API library, this, this property is stored. So we're taking this,

taking the body, and then we're converting it into a dictionary. And then we're storing it inside a

property called payload, but you can name this whatever you want. And so what we can do is we

can take this data. And then we can say, let's say we're going to return back a new new post,

and then we're just going to send the data. So we'll say title, and we can actually change this

to a f string. And we'll say title. And then we can pass in payload. And you'll see that we can

just reference the title property because it's just a regular Python dictionary. And we'll say

that the content is going to be payload content. So let's save that. And then now let's hit send.

Now look at this, we got our new post innocent. Whoops, it looks like I made a mistake. Yeah,

no, actually, that's correct. title, top beaches in Florida content, check out these awesome beaches.

So that's pretty simple, guys, I showed you guys how to not only send data in the body within a

postman request, we're also able to extract that data and send it right back to the user. Now in

a real application, we would take the data, and then we would normally store that data inside

our database so that we can create a new post stored in the database. And then now anytime the user tries to retrieve the post, we can fetch that data from the database, we don't have a

database set up just yet. So for now, I'm just showing you guys how to extract that data and then send it back in the request. In the last lecture, we learned about how to work with post

requests, we learned about how to send data in the body, using postman as well as how to extract that data within our path operation so that we can perform some logic. And there's some issues that

we're running into at the moment, based off of the way we've kind of set up things. Alright, and

the first thing is, it's kind of hard to get all of those values from the body, we have to, you know,

extract each one individually. On top of that, the client can send whatever data that it wants. And

this is a big issue, right? I don't want the front end to send arbitrary data. If the user is trying to create a post, I want the title, I want the content, nothing else, right? I don't want them

to send any extra data. And on top of that, the data itself isn't getting validated, right? So

how do I ensure that the user is sending what I want, right? What if the user sends a blank title,

I can't have a post with a blank title. So how can we validate that the data that the user sends

is actually valid, right? And ultimately, what we want to do is we want to force the user into

a schema that we can expect, right? That's the term that we always use the API schema, where we want to define exactly what the data should look like, so that it's almost like a

contract between the front end and the back end saying, Hey, the back end sends a message to the front end saying, Listen, I expect my data to look like this. If you don't send me the data looks

exactly like this, I'm going to give you an error. And that's the way you want to work with APIs, you want to explicitly define what the data should look like, so that the front end can send you

exactly what you expect it. So let's see how we can do that using fast API. Now, what we're going

to do is we're going to make use of a library called pedantic. Now, we've already got this installed, because we use that all flag when we did pip install fast API. So if you actually go

back to your code, and go to your lib folder, you should see pedantic somewhere in here. And you can

see that pedantic is already installed. So we can make use of pedantic to define what our schema should look like. So let me quickly show you how to work with pedantic. It's really simple. But

keep in mind, technically, pedantic has nothing to do with fast API, it's its own complete and

separate library that you can use with any of your Python applications. Fast API just makes use of

it so that we can define a schema. So let's import pedantic. So let's say from pedantic,

import, base model. And so if we go down to our, you know, our create posts,

path operation, you know, ultimately, what we want to do is we want to tell the front end what

a post or a new post should look like, what data do we expect? So let's figure out what data we want for a specific post request. So two things that we want, we want a title, which is going to

have, which is going to be, you know, a string, essentially. And then we want the content, which

is the content of the post, which is going to be, you know, some sort of string, right. And so we want the we expect the user to send both of those things. And then we don't really want anything

else. We don't want the user to send any other piece of data, we just want these two things. And we can put in any other pieces of data we want. So if we want the user to pass in something like,

you know, what is the category of the post, we can include that, we can maybe include maybe the

number of I mean, I don't know, you can really think of anything, maybe a Boolean that kind of

represents, you know, is this a published post? Or do you want this to be saved as a draft? So you

can construct it however you want. But we're just going to stick to title and content. So the way

that this works is, I'm going to remove this comment right here. We're going to define a class,

we'll call this class, and then we'll give it whatever name we want, it's going to represent what a post should look like. So I'm just going to call this post. And then this is going to

extend base model. So this is what makes it a special pydantic model, we just extend base model.

And then here, we pass in the different properties for our post. And like I said, we want a title.

And we also want a the content. Now, what we pass here is going to be what is this type of data. So

if we go to this pydantic library, you'll see that there's the different field types. So we can set things to be a Boolean, we can set it to be an int float string. So all of the common Python types

list tuple, it's all available within pydantic. So we know what a ultimately what a title should look

like. So what do you guys think should be the field type for the title property? Well, I think

it makes sense. It should be a string because this looks like a string, it's got some text, it's got some text, it probably should be a string. So let's set this to be string. And the content

should be the same thing, it should also be set to string. And now what we can do is let's take this

model and go down to create posts. Instead of extracting the payload, what I'm going to do is

I'm going to reference that post pydantic model. And then I'm going to save this as a variable

called post. Once again, they don't have to match. But since this will represent the post, I can call this maybe new underscore post or something like that. And then, and then reference

the post pydantic model. So what's going to happen is, because we pass this into our path operation,

fast API is automatically going to validate the data that it receives from the client based off

of this model. So it's going to check, hey, does it have a title? If so, is it a string? If it if

the title doesn't exist, or if it's not a string, and maybe we pass an integer, then it's going to throw an error, it's also going to check for us if contents available. If it is available,

it's going to make sure that it's a string. And if contents not available, or if it's not a string, it's going to throw an error. So it's doing all of the validation for us. And then we can

it's defining the schema of what it should look like for the front end, what kind of data should

the front end send to us. So we're going to remove all of this nonsense.

I'm just gonna for now just say data. I don't know, new post for now.

And now what I'm gonna do instead of print payload, we're going to say print new underscore post. So let's save this. And then I'm gonna send a post request. Okay, so that updated fine.

But let's take a look at what this printed out. So take a look at what you're printing out. Look at that. It automatically extracted all of that data for us. So now we can access, you know, post dot

title, and we can get the title of the post. And we can also access post dot content to get the content of the post. And just to prove that to you guys, we'll say post dot title. So we'll save

that will send a request. And now look at that look how easy it is to extract that data because

it's already assigned to that new post variable. And we can just access each property based off of

what the model is defined as. Now that's great and all. But let's check to see if it's actually

performing all of that validation. So if I go to my postman, and I remove title,

let's see what happens. I'll hit send. Look at this. Look at this, it's saying that the inside

the body, there's a title field and it's saying a value error, it's missing. Now we didn't tell

fast API just to send this, but it automatically does the validation for us and sends back an error message. And then it sends back a status code. So this is the status code of the message

it sends a 422, we can change that later, don't worry about that. But it's automatically performing the validation. And that's what's awesome about this. And if we, if I add the title back,

what was it top beaches in Florida? And instead, actually, I changed this to be

a one or something. And I need that comma. Let's see what happens if I hit send. It looks like

there's no errors. And that's because the number one can actually be converted into a string. So

it's not going to throw an error on that. And that's perfectly fine. And I'll and that's perfectly

fine. So that's not a big deal. But let's change this back. Like I said, it's going to try to

convert whatever data we give it to a string. So as long as it's able to convert it to a string, it's okay in any integer that we pass can be converted to a string. So I'm going to change

this back and I'll add top beaches in Florida. Florida. Let's see what happens if we remove the

content now. I hit send. Look at that. Now it's saying the content is missing. Perfect. So our

validation is working exactly how we expect it to. And then I forget what what was it something

something beaches. I can't remember what it was. Now let's say that we want to

assign a property. That's optional, right? Like what if we want it to make it so that the front

end can either choose to send some piece of data or not send a piece of data. So let's say that

we want the user to be able to define if a property if a post should be published or not,

well, we can create a field called published, which is going to be set, which is gonna be a type of

Boolean. And we can say, you know, first of all, we can say, if the user doesn't provide us a value,

we can give it a default value. So here I'll say true. And so if the user doesn't provide published,

then it's going to default to true. If it does provide published, then whatever value you give it, that's what we're going to use it as. And I'm going to go down here. And we're going to change

this to we're going to grab the published value. And then down here, we'll say published, whoops,

can be set to true. So let's hit send. And we can see that it got set to true. That's good.

If we set this to false, it's send, we can see that it's false. And then if we remove this all

together, move that comma as well, hit send. Look at that, it defaults to true. So now we've created

an app an optional field for our schema. So the user doesn't have to provide this, and it's going

to default to true in this case. Now, let's say we wanted to create another field. However, instead

of giving it a default value, if it's not sent, we want it to default to none. So we want it to be

completely optional. And we're not going to store any value. And if the user doesn't provide it, what we can do is let's say the field is a rating, let's say the user can give each post a rating,

what we can say is optional. And we're going to have to import optional from typing from the

typing library. So import optional. And then we have to pass in the type. So what is it going to

be? In this case, a rating, I think an integer makes sense. And then we can say equals to none.

So this is going to be a fully optional field. And if the user doesn't provide it, it's going to default to a value of none. And so here, I'm just going to get the the value of our

rating. And so if I hit send right now, in our body, we don't have a rating field, I hit send,

you can see that it defaults to a value of none, because we set this to be optional, none. However,

if I pass in a rating field, I need to give it a value, some kind of value. So I'll say we'll give

this maybe like four stars or something. I hit send, we can see that now look, the value of rating

is set to four. And then finally, the last thing I want to note is because we set the type to be an

integer, so even though it's optional, we still have to specify the type. If I give this a value of a string, so you know, something like Hello, which is not a valid rating, take a look at what

happens. Look at that. It says in the body, the rating field, the value is not a valid integer.

So it wasn't able to convert whatever value we sent into integer. And so that's why it's throwing

an error and saying like, this does not match up with schema, and it's throwing an error. And so that's what's awesome about this is now we can ensure that our front end is sending the exact

data that we expect by using these pedantic models. So moving forward in this course,

we are going to really make use of pedantic models to ensure that the schemas not only receiving

data from the front end, but also sending data back is all matching up with our organized schema.

And actually, there's one last thing I want to show you guys. And that is that when we actually

kind of extract that data and save it into new post, it actually stores it as a pedantic model.

So it's a specific pedantic model. And each pedantic model has a method called dot dict.

So if I do, if I print new post below this, what we can do is if you ever need to convert

your pedantic model to a dictionary, all we have to do is write the name of the variable,

we say dot dict. This is going to take that pedantic model, and then it's going to convert

it to a dictionary. So let's print that out. Let's save it. Let's hit send. Whoops,

and I forgot to, it's still throwing a validation error, but that's to be expected. So we'll say change that to four. All right, take a look at the two different things. So this is a pedantic

model that's just printing out the different properties of that of that model, whereas this is a regular Python dictionary. So we can just send back a dictionary if we want to. So we do

return new post and save that now if I hit send, we're just sending back a dictionary. And so now

we send back the data with all of the different properties. And so you'll see that this is actually a nice little handy tool to be able to convert it to a dictionary, which is something that we'll be

needing to do in some of the future lectures. So I wanted to make sure we just cover our bases real quick on that. And also, I don't like calling this new post, I'm just going to change this to post

for now, because I think that's a little bit better, my opinion, because it is just a post,

we don't need to know that it's a new post, it clearly is. And let's just double check that everything works, hit send. Perfect. In this lesson,

we're going to talk about what a CRUD application is, as well as what our standard conventions when it comes to creating an API for a CRUD based application. So CRUD is an acronym that represents

the four main functions of an application. So any application, regardless of what it is, needs to be

able to create things. So in our case, since we're building a, you know, a social media type

application, we need to be able to create posts make new posts, we need to be able to read posts.

And so that includes, you know, retrieving all of the pre existing posts, we need to be able to update a post if we want to implement that functionality. So if we decide to change what

our post says, we would use the update functionality. And then finally, we need to be able to delete a post. And so the CRUD that represents the four main functions of any CRUD based application. So

it's nothing more than an acronym. However, I created this slide so that you guys can understand what our standard conventions when it comes to creating an API for a CRUD based application,

because there are certain best practices that we need to follow. And so when it comes to naming

the URL and the paths for each operation, there's a standard convention. And the first thing that I

want to point out is since we're working with posts, it makes sense to name all of the URLs, all the paths with slash posts. And it's important that you use the plural form of posts, you don't

want to do slash post, you want to do slash posts as in plural, this is standard convention for

API's. And if we were working with users, and we want to do be able to create, read, update and delete users, it wouldn't be slash user, it would be slash users. So always use the plural that

standard convention. Now when it comes to creating a post, right, that's always going to be a post

request. So we've got the create functionality right here. And we can see that we have to send a post request standard convention, anytime you want to create an entity, it's going to be a post

request. And the URL or the path for that specific request is always going to be slash posts in this

case. And if you want to see what that looks like, for the decorator and fast API, it's pretty simple, you just do app dot post slash post. So this is something you guys already know. Now, when it

comes to read functionality, which would be, you know, reading or retrieving pre existing posts, there's actually two different path operations we're going to create. So the first one is going

to be slash posts. And this is going to be for retrieving either all of the posts or multiple

posts, depending on what filter that we use. And so when it comes to retrieving information from a

database or anything like that, retrieving data, it's always going to be a get operation. So you send a get request to slash posts. And if you want to see what that face to the decorator on fast

API would look like, it's just app dot get slash posts. Once again, we already have this set up in our application so far. However, there's also going to be another path operation for reading,

right? And that's if you want to get one individual post. So if we want to get detailed information about one specific post, we're going to send a get request to slash posts slash and

then we've got this ID right here. So anytime you create something, what's going to happen is

anytime you add something to a database, the database is going to give it that specific item, a unique identifier so that we can uniquely identify that specific entry. And so if I want

to get detailed information about a specific post, I would just send a request to slash posts,

and then pass the ID of that specific post I'm interested in. So that's what this ID represents.

And within fast API, if you want to see what that actually looks like, you would just do app dot get slash posts. And then you do curly braces, and then ID and that'll allow you to extract

the ID from the specific URL of the request. And then we can, you know, take that URL,

sorry, take that ID, and then you know, send it out to our database so that we can retrieve the information. So there's always going to be two specific path operations for read functionality.

Then we have update. So this would involve updating a pre existing post. So maybe we,

you know, posted out something, and then we realized we said something offensive, and we want to update it before anyone takes a screenshot of it. Now, when it comes to updating,

right, there's two different HTTP methods that we can use, we can use put or patch. And it's really a matter of user preference, the only difference is that I want to I don't want to spend too much

time on it is that when we use put that you the idea is that you pass all of the information

all of the information for updating it. So all of the fields have to be sent to the to the API

server, whereas a patch, we can just send the specific field that we want to change. So put,

you want to change the entire thing, you have to pass every, every field, even if it's going to be the same, and most fields don't change. Whereas a patch, we would just change the one specific

field. So as an example, as a, you know, if we're working with users, actually, if we're working with posts, and let's say I wanted to change the title, all right, I want to update the title of

a post, if I used a put request, I'd have to give the new title, and I would have to give the pre existing content, right? Because the put, the idea behind put is that you have to provide all

of the same information, so that we can on the back end, just take all the information and then update the entity. Whereas a patch operation, I can just send the title, and then my back end

should know how to just update that one field, we're going to stick with put I believe, in our

application, but really, at the end of the day, it doesn't really matter. It's just a matter of use of preference. But with update, just like when it comes to retrieving one specific post, we have to

pass in the ID so that we know which specific post we want to update. And for the decorator and fast

API, the only thing that we change is it's going to be app dot put. And then we can pass in the ID

like we did before. And then finally, we have delete. So if you want to delete a post, once again, you're going to send a delete request, so that the HTTP verb is going to be delete. And then we have

to pass in the specific ID of the post as well. And then this is what the fast API decorator is

going to look like. So it's actually not that hard. It's fairly simple. And you'll see that once you create one crud API, creating another one is almost a matter of copying and pasting really.

And so in the next video, we're going to make a few changes to our API so that we can make sure that we follow this naming convention. Because right now, I believe when it comes to creating a

post, instead of just using slash posts, we call it slash create posts, which once again is not following best practice. So we'll update that in the next video. Alright guys, so in the last

lesson, we learned about best practice and naming conventions for an API. So what I want to do is quickly go into all the code that we have and make changes so that we follow best practices. And so

if you take a look at our get requests, you can see we say send a get request slash posts. That's

perfect. We don't need to change anything to that. However, the issue is, is our create post functionality. So the path for creating posts, we can see that we send it to a URL of slash create

posts, that is not going and following best practice. So what we do just change this to be slash posts.

And that's all we have to do. And so we'll save this. And we'll just double check inside our post

man just to make sure we update that as well. So this is going to be to slash posts. And then we'll just test this out to make sure we didn't break anything. And it looks like it's still working

just fine. Alright guys, so if we take a look at our code, you can see that for our create post

path function, we're not actually doing anything with the data, we're not actually saving the post anywhere right now, we just print it out and then send it back to the user. So that's not exactly

how a real application would work. And so what I want to do is I want to start saving these posts, I want to start turning this into a real fully functioning application. Now, ideally, we're going

to save this within a database, because that's how any application works, you want to take a post, you want to save it in database so that you can persist that data. However, we're not quite ready

to handle working with the database, a little complex, we're going to get to it in this course, however, I want to keep things simple. So we're going to do is we're going to save the posts in

memory. And how do we do that easy, I'm just going to create a variable, just globally,

that's going to store all of our posts. So I'm going to say my underscore posts.

And this is just going to be an array. And so this array is going to contain a whole bunch of posts objects, right. And what each post is going to be is going to it's going to be essentially a

dictionary. And the dictionary is going to look kind of like this. So we're going to have a couple properties. So we already know that our post is going to have a title. And then that'll have,

you know, whatever, you know, title of post one or whatever. And then we're going to have the content,

of course. And I'll just say content of post one, this is just an example post. And then what we'll

also do is, like I mentioned before, anytime you save an applicant, save a piece of information

within a database, the database is going to create a unique identifier and ID. Now, since we're not

working with databases, there's no ID, however, it's going to create issues. Because, you know,

if you remember, when it when it comes to working with CRUD based API is we need to be able to fetch

data and update data based off of the ID of a specific post. So we do need to still have an ID so that we can uniquely reference any single item within this array. So we're going to have

another field called ID. And then this is just going to have, you know, be some random integer,

you know, 12345. It doesn't matter. It's just got to be unique. That's all that matters. So this is what our post is going to look like. And we're going to just store it in this array. So we're

going to have multiple posts. And I'm going to keep this one hard coded in here. Because every time we change our code, and hit Save and refresh, guess what, it's going to clear this out. Because

remember, this is just stored in memory. So every time our application restarts, we're going to lose that data. So just to keep things simple, I'm going to hardcode another another entry. So for

this post, we'll say the title is favorite foods. And the content will be I like pizza. And we'll

just give this an ID of two. All right. And so now that we actually have some place to store our

posts, we can actually test out our get post functionality to see if it works. So I'm going

to save this, we're going to go back to postman. So find the one with the get operation where we're retrieving the posts. And then we'll hit send. Let's see. Well, when we hit send, nothing

happens, of course, because we actually have to update the code to send that data. So let's go back to our code. And let's go to our get posts. So right now, we're just sending back this

information. So let's update this so that we return my posts. And this should be fairly

straightforward. What we can do is we can just keep this property called data. And we can just remove this and just pass along my underscore posts. And so what's going to happen is fast API

is great. Because if I pass in an array like this, it'll automatically serialize it. So it's going to convert it into JSON, JSON has something that's also very similar to an array. And it's going to

change that into a JSON format so that we can send it over our API. So that's all we have to do, we just have to pass in the array, and it's going to send that. Now, if we try this, look at that,

so we get the data property. And within here, we have an array. So this is JSON also has a concept

of arrays. And then within here, you can see we've got our post one and our posts two. So that's

really as simple as how to work with our API how to actually retrieve posts. In the next video, we're going to update the create post path operation so that we can figure out how to add

a new post into our my posts array. All right, guys, so let's update our create post path

operation function so that we can retrieve the title and the content from our front end,

and then create a brand new post and store it within our my posts array. So how do we do that?

Well, we already know that we can retrieve our post by referencing this post variable,

because this will take our schema, which remember, we defined with pedantic, it's going to do all the

validation, and it's going to store it within post. And so this is still going to be a pedantic model. However, our our array is going to be an array of dictionaries. So we have to convert that to

dictionaries. And we already know that we can convert any pedantic model to a dictionary by doing dot dict. And then that'll turn it into a standard Python dictionary. And at that point,

it's pretty simple. This is just standard Python. At this point, we can just do a my underscore posts dot append. And then we can append post dot dict, just like we did before, we don't we can

remove these print statements, they're just cluttering things up. However, there's one little

issue. Like I said, we need to have an ID for every entry. And normally, the database handles

that. But since we're not actually working with a real database, we're going to have to do this in software. So what I'm going to do is we're just going to assign it a random integer, not really

that reliable. But if we pick a random number between one and, you know, 10 million, the odds of us hitting the same number twice is almost next to none. So what we're going to do is we're going

to use the random package. So we'll say from random import, ran range. And this is what we're

going to use to create a random number, or a random integer. And so instead of doing this,

I'm actually going to remove this for a second. And I spelled append wrong as well. What we're

going to do is I'm going to say, post underscore dict, which is going to be the post pedantic

model converted to a dictionary. I'm going to set that equal to post dot dict. Okay, so this is

going to be the dictionary. And so now that we have a regular Python dictionary, what we can say is post underscore dict. And then I'm going to reference the ID field that I'm creating. And I'm

going to assign that to be a random number. So we're going to give it a range of zero to and then

just pick some really, really, really, really large number. So this is going to ensure that pretty much any entry won't it for development purposes is going to be unique. We'll append that to the

array. And then here's the thing when it comes to how a usual API works is that when a front end

sends the data to create a new post, after we create the post stored in our database, we should send back the newly created post, including the brand new ID. So let's send that back. So in this

case, I'm going to send back post underscore dict, because that's going to be the brand new post

that we add to the specific add to our posts array. So let's try this out. Let's go to our post

request that we have. And let's see all of our data. So we've got a couple of things title content

rating, I don't really care about the rating. But I'll just leave it in there for now. It shouldn't matter. And then we'll just hit send. And let's see what happens. And it looks like we got an

error. So let's see what happened. All right, it looks like there's an and I already see what

happened. I forgot to actually include post underscore dict. We actually have to pass in what we want to append to the array. Let's save that. Try this again. Hopefully no errors. Look

at that, guys. So it looks like we got back the newly created entry. And we can see that it has

an ID of whatever that number is. And if we do a get request now to retrieve all of our posts,

we should see that newly created entry. So let's take a look. But we've got post one post two.

And then we've got that brand new post. Look at that, guys. So we are a little bit less than

halfway done with creating our CRUD based application. Now, before moving any further

and writing any more code, what I want to do is I want to actually save these requests, because right now they're just kind of stored in memory. If we close out postman, it'll still

remember it. But what we can do is we can create a collection. So here, I'm going to select create collection. And I'm going to give this a name. So I'm just going to name this after my project.

So I can call this, you know, fast API course, or, you know, since this is social media app,

we can call it whatever we were to call it, I'm just gonna call it fast API course. We'll save that. And then what I want to do is I want to save these two requests, so that I don't have to

remember this in case they actually get deleted. So I'll hit save, save as, we'll save it. And then

you can give it any name. So this is going to be, I forget, this is the get request. So I'm going

to say I'm gonna call this get posts, and then store it inside this collection. And so now within

this collection, you can see this request is stored in there. I'm gonna do the same thing for the post request. So this is for creating posts, we'll do save as again, I'm going to say, create

post. And then it's already remembers the most recent collection, but go ahead and select the

collection if it didn't remember that. And then we'll hit save. And so now they're both saved in here. And we can easily bring these up anytime even if we close out all of our requests. So I

closed everything out, and bring that right back up, it's going to remember everything. And then same thing with the post request, I go to the body, it even remembers the fields. So Postman,

one of my favorite tools, when it comes to working with API's, and you know, as this course goes along, you're going to continue to learn more and more things about Postman. Okay, guys, let's

continue building out our CRUD application, the next function I want to implement is retrieving one individual post. And so let's define a function for that. So here, I'll call this get post,

keep in mind that this is singular. So I call this get post, whereas to retrieve all posts, it's get posts. But like I said, the name of these functions don't actually matter. It's just more

for for you more for readability. And the decorator is going to look like this. And so this is based

off of that slide I already showed you. So it's going to be a get method. And then here, the URL is going to be slash posts. Id, right, because the user is going to provide us the ID of the

specific post that they're interested in. And so that's going to get embedded in the URL. So they'll

send a get request to slash post slash and then whatever ID so if they want to see the information for post one, they'll pass in a value of one. And what this is actually referred to the proper

terminology for this is that this is called a path parameter. So this ID field represents a path

parameter. And this parameter happens to represent the ID of a specific post, the user's interest in seeing. And so what we can do is fast API will automatically extract this ID. And then we can

pass it right into our function. So now our function has access to whatever value was in that URL right there. And so if we want to, I can do a quick print of ID. And then we'll just return

some hard coded data. So I'll just say data, as we'll call this, how about post underscore detail,

I'll say this is the post you're interested in. Or even better, I can do is we'll change this to

an f string. And I'll just say here is post. And then we can just pass an ID. So let's save that

will go to postman. And what we want to do is we want to create a new post, but let's create it in our collection. So I'm going to go in there, select Add request, give it whatever name you want,

I'll say, get one post. And then for the URL, just copy the get posts URL. And then we want to pass

in the ID that we're interested in. So we just do slash. And then in this case, I'm going to get the post with an ID of two. And the reason why I'm doing that is because we've hard coded one

of our posts have an ID of two. So I know that's always going to be there. And then we can just try sending this and see what happens. So it says post detail, here is post, and then post number

two. So it looks like we were successfully able to extract the ID, the path parameter that was

passed into the specific URL that the user sent a request to. So we now have access to that at that

point, we can just find whichever entry in my posts has that specific ID. Now we have to implement

the logic for actually getting that post. And so there's many different ways of doing this. And I'm telling you right now, this is probably not the best way of doing this. I'm not really even

a Python expert, I'm sure there's much better ways of grabbing this information. However, keep in mind the code is going to be changed later on once we start working with the database. So

this at this point is just basic Python logic. And I do want to keep you I do want you guys to keep

in mind that this may not be best practice for the best way of retrieving an individual post, but I'm just going to create a simple function. And it's going to be called find post. So this

is how you find a post by an ID. So the so we'll pass in an ID in this function to retrieve the post. And what we'll do is we'll iterate over the my posts, we'll say for P in my posts.

And we'll say if P so P represents the specific post that we're iterating over. So if this specific post has an ID, which equals the ID that was passed into the function,

then we'll return P or return that specific post. And then at this point, we can call this

function. So I'm going to remove that print statement and say post equals find underscore post

ID. And then for this, we can just remove this and just return post. Let's save this,

let's go to back to postman. And let's try this out. And it looks like I got an error. So something

happened. And let's actually take a look at our code. Well, guys, I think I found the issue. So

the reason why we keep getting none, right, if I keep sending things send, it says none. And what

I did was I just printed out the post to see what we got. And it actually just prints out none. So for some reason, we're unable to find posts. And I think I know exactly why. And so what I'm going

to do is I'm going to do a print of ID again. And this is going to teach us an important lesson.

So send another request. And it prints out two. However, what we're going to do is,

I'm actually going to get the type of ID. So I forget how to do that. I think it's the type,

I think you can just do type in Python. So I'm going to figure out what is the actual type of

ID. And now if I send this request again, right, you could see that the type is actually a string

and not an integer. And so when we pass this check in where we say if P ID, so if we get the ID

field and compare it to the ID that we pass in, it's never going to equal that because one's an integer, the other one's a string, they're never going to be equal. So the first thing that we

actually have to do is before we call this function, we have to convert it to an integer. So I can just say, int, that's going to convert it to an int.

Save that. And at this point, if I send this, it should now work. Look at that. So keep in mind,

guys, anytime we have a path parameter, it's always going to be returned as a string, even if it represents an integer or a number, we always have to manually convert it ourselves.

So don't forget to do that. Now, there is one little issue with what we're doing. So everything's

working. And if I actually change this to a one, we should get a different post. So everything's

working great. However, what happens if I type this? Well, let's hit send. Well, we get an error,

right? Because we're trying to convert this to an int. And it's going to throw an error. And then instead of sending back a nice, you know, built in response, we just get an internal server error.

And the user has no idea what exactly is wrong. So we want to provide it feedback. So how can we perform some kind of validation to ensure that whatever data that's passed into this path

parameter can actually be properly converted to an integer? Well, we can perform validation with

fast API. So here, for ID, what we can do is we can say I want this to be an integer. So what it's going to do is it's first of all going to validate that it can be converted to an integer. And then

it'll automatically convert it to an integer for us. So we no longer have to convert this ourselves.

So here, I could just pass an ID because this will make sure that it's already converted. And so now, if I save this, and I change this back to a number, first, let's make sure that

everything's working. So it automatically converted it to an integer. And now if I pass in, you know, a string, it's now going to throw an error, it's gonna say for a path parameter of ID, you can see

that this value is not a valid integer. And so now the front end has a good way of understanding

what they did wrong. And, you know, this can be anything, right? So if you wanted this to be a

string, right, we can have this automatically get validated as a string and convert it into a string, so that if they do actually send a string, no errors, right. And then if they tried to actually,

even if you put in a number, it's not going to throw an error, because any number can actually be converted into a string. But we want an integer. So I'm going to change this back to an integer.

And then we'll just code this as two. Perfect. Make sure you save your request. And so now we've now

implemented our third function within our CRUD app. So we've just got two more, we got to handle

updating and deleting posts. But we've got all getting all posts, creating a post and then getting

an individual post. And you'll see that for the last two, it's pretty much the same thing, right, we just have to define our specific decorator, and then define the logic for actually creating

and deleting a post from that array or updating a post as well. Now, before we move on, I do want

to show you guys one potential issue that you could run into if you don't quite understand how these routes work and how order matters within fast API. So what I'm going to do is I'm just

going to create a dummy route and you guys don't need to follow along on this is just a quick little demonstration. And I'm just going to make this another get request or handler for a get

request. And then this one's going to be posts slash latest. So what this will do is when the user

sends a request, a get request to this specific path, I use path, we're going to grab whatever the latest post is. And so here, I'll just say def get latest post. And so all I'm going to do

is I'm going to reference our my posts list. And I'll say we'll get the length of my post.

And then we'll just minus one. So this will grab the latest post. And then what we're going to do

is just return that here, we'll say detail. And then we'll pass in and actually, let me store

this in a variable post equals and then we'll return post. We'll save this and I'm going to

show you what happened. So let's create a new request. I'll just copy the URL from the previous

one. Then here, we're going to change this to latest. Let's see what happens. Interesting,

we get an error. So what exactly happened? Well, let's take a look at the error. It's saying that

we have a path parameter called ID. And it looks like it's saying that this is not a valid integer.

So I'm not even sure why it's referencing this error. I guess if we take a look at our code,

right, there's, there's no path parameter here. So what is exactly happening? Well, let's take a look, right? Our request looks like this. So it's going to slash posts slash latest.

So when we send this request, what's going to happen is that we're going to start all the way at the top. And fast API is going to go through the list of all of our all of our paths. And it's

going to find the first match. So we have one at just the root URL. So it's not going to match

that. We have one at slash posts, it's once again, not going to match that. This one is for a post

request. So it's not going to match that because we sent a get request. But then something interesting happens here when we get to this get request, right? So this handles a get request, and then it

matches slash posts, and then some variable. So technically, that variable could be latest,

you see the issue that we're running into, because there's no way for fast API to know that that route was meant for that that request was meant for this specific path, right? Because

it does technically match on this. And then what happens is since it matches on this route, it then tries to perform validation on ID, which is in this case, it's going to end up being latest.

And then it's going to throw an error because latest can't be converted to an integer. And so this is the example of where order matters. So you have to be careful when you structure your

API, especially with your with your paths and your URLs, you want to make sure that you don't run into this type of issue. So you know, one thing in this case, you could do is just move this up,

that would fix the issue. Because now if you save this, and then run this, right, it works.

And if you try to reference a specific ID, that's going to work as well. Well, in that case,

let's try one. Yep. And so that works as well. Because slash posts slash one will never match

this one, it'll only match this one. So be very careful when it comes to the order, it always works

top down. So anytime you're working with path parameters, it could potentially result in you guys accidentally matching other routes by accident. So you know, there's different ways to

get around this, like I said, you can just move this up. Or if you wanted to change the URL altogether, so that this is like a slash post slash, I don't know, you know, just put in another

keyword, something like a recent or something recent slash latest or something. Well, actually,

even then that would, yeah. And so just keep. And so I just want to make sure you keep that in mind when you're structuring your API, because anytime you have a path parameter, it could result in you

accidentally matching requests that were meant for a different, for a different route. So I'm just

going to delete this, this was merely just for demonstration purposes. And I just want to make sure that you guys understand the fast API just looks at all of your paths and just works its way

down the list till finds the first batch. For our get post path operation, specifically the one

where we retrieved one specific post, we do run into a little bit of an issue. So if we go to our

postman real quick, and send a request to get one post, but in this case, instead of doing one or

two, what I want to do is I want you to put in the ID, put in an ID that doesn't exist. So we only

have right now, posts with an ID of one and two, what happens if we send it with a ID of five,

you can see what we get back, it says, null, right? And I don't like that, because it doesn't really

give the front end any feedback as to what exactly is happening. So they don't actually know, you

know, they don't know if some kind of error occurred, or if we were unable to retrieve this information properly, or if there's a server error, or if this item doesn't ultimately exist. And so

we need a way to accurately tell the front end that, hey, the ID that you're searching for does not actually exist in our database. And the best way to do that is through a method that I'm sure

you guys are already a little bit familiar with. So right here, I've got my GitHub page for our

course. And you can see it's just GitHub, my username and then the name of the repo. But if

I search for if I put in a whole bunch of letters afterward, what's going to happen is GitHub is going to look for a repo with this name that doesn't exist. And let's see what happens. It

gets a 404. And I'm sure you guys have seen a 404 error at least once before in your life. So

that's a specific HTTP status code that represents that this item was not found though it does not

exist. And HTTP status codes are important. We haven't really talked about it in this course up at this point, but there's a lot of different status codes. And if you actually just search

for HTTP status code, you can just grab one of the top links, I'm going to go take a look at the

Mozilla one, and you'll see all of the different HTTP status codes. And you'll see when to use them. Now, most of the time, you're going to see that we get a 200 response back, that's the default

one, the fast API sends that usually means that everything's good, everything worked. That's why it says okay. However, we do have other ones that we do also commonly use. So anytime you create

something, so within your CRUD application for create, anytime you send a POST request,

usually, after you create the entity, you send a 201 back instead of a traditional 200. So there's

a lot of HTTP status codes, and we're going to cover all of those in future lectures. But the ones we're interested in is for when we have an error. So we scroll down 400 usually means there's some

kind of bad error, something happened. And most importantly, we want the 404 not found. So the

server cannot find the requested resource. So that's exactly what we're looking for. Keep in mind, there's also 500 status codes, which means you know, some kind of server error, server error

or server failure. So what we're going to do is I'm going to go back to our code. And what we need

to do is we need to manipulate the response. Because right now, we're getting a 200 back,

we're getting a status code of 200. If I send it, it says null, and then it just sends 200. So that doesn't really give us a good idea as to what's happening. So how do we manipulate the response?

Well, we have to, first of all, import the response from fast API. And then what we're going to do is

we're just going to pass it in as a parameter into our path operation function. So I'll just call

this stored in a variable called response. And so once you get access to the response object,

we can tweak it however we want. So what I'm going to do is, after we search for post, if we didn't find a post, I'm just going to do a quick check, and I say, if not post,

that means if we didn't find a post, we're going to do is we're going to set the response. And then we're going to grab a property out for response called status code. So here we can tweak the

status code of the response, I'm gonna say, hey, I want this to be a 404. All right, now let's save

it. Now if I hit send, it still says post detail none, but take a look at the status code, it's now

updated to 404. And if I change this to an ID that does exist, right, we get the post properly,

and the status code changes to 200, which means everything is good. But one way of doing it, however, there's a slightly better way of doing it, same concept. But instead of hard coding,

the value or trying to remember it, what we can do is we can import from the fast API library,

something called status. And so now instead of having to remember what to use, we could just

type in status. And then it's going to show you all of the different HTTP codes. And so now you

could just quickly just look through which one ever one sounds the most accurate. So we'll grab the 404. And now you don't need to worry about putting hard coding in a number, we can just

reference, you know, I guess it's an it's probably an enumerator, but I'm not really sure. So it

doesn't really matter. And then that's all you have to do. So let's test this out again. So 200

good changes to five 404 perfect. But the next thing I want to do is I don't want to return

null that looks ugly. So instead, I'd like to actually throw an error. So in this case,

in this if statement, I'm just going to call a return that only is going to ever run if post doesn't exist. And we'll just say, in this case, detail, or we'll say message, I'll just say

message. f string, I'll say post with ID. And we'll pass in what was the ID, I'll say was not found.

All right. And now if we try this, look at that, we get our error post with ID was not found,

that matches up with the ID that we gave it. And we got our 404. Now this was a, this is one solution.

However, I think this is a little bit sloppy. And there's a better way of doing it. Instead, what we can do is we can rage raise an HTTP exception. So this is a built in exception into

fast API, that'll automatically, you know, you can pass in what the specific error code you want,

as well as the message. And so that way, you don't have to hard code all of this. And it just makes everything look a lot simpler. So we'll go to the fast API up here. And we're going to import something

called HTTP exception. And now we can delete all of this nonsense code. Actually, I'm just going to

comment it for now, just so I can reference it in a second. And all we have to say is we'll raise an exception. So we raise HTTP exception. And then we have to pass in two things. So first is the status

code. So we'll set the status code to be status dot and then same thing, right? So far, nothing's

really changed. And then here, we'll just pass in the value for detail, which is going to be the

message that fast API automatically responds back with, and I'm going to pass in the same exact F

string. And so now we've basically replaced this with just this one line right here, this HTTP

exception, I think this looks a little bit nicer. I don't like having to do the set the response, and then having to pass in, I don't like having to pass in the response into the path operation

function, having to set a property, and then having to return my message, we can remove all of this nonsense. And I can get rid of all of these comments. And I think this is just a little bit

cleaner. And moving forward, we're going to be using these HTTP exceptions a lot. Because all we have to do is just pass in what's the HTTP status code, and then the message we want to send back

to the user. And then that's what's going to be sent to them. So now once again, we're going to try this out. And look at that. Alright, so we got the 404. And we got the message, the detailed

message, right, lot cleaner, a lot simpler. Now, before we move any further, and before we wrap up

this video, I did mention that anytime we create something, we should send back a 201. So if we go

back to our create post, and then we'll just create a new post again, you just send this, we created

a new post, look at the status code that gets sent back, it's got it gets sent back at 200. And that

is wrong. Remember, anytime we create an entity based off of that documentation, we should send a 201. So how exactly do we send how do we change what the default status code is for a specific

path operation? Well, what we can do is we'll go back to our code. And let's find our create post.

And if you want to change the default status code, what we do is inside the inside the decorator,

we'll pass in another option. So we'll say status code here. And then we set this to be status and

then whatever our specific status code is. So I want to a one. And then that's all you have to do. So now, by default, anytime someone sends a request to create posts, we're going to send a

201 created. So we'll save that we'll give it another shot. If I try this again, now we get a

201. Perfect. At this point, I think you guys will have a solid understanding of how to change status

codes, whether it's because we're trying to throw an exception, or if we want to just change the default status code of a specific path operation. All right, guys, so now it's time to move on to

deleting a post. So to delete a post, remember, we're going to start off with our decorator,

and it's going to request or it's going to require a delete HTTP request. Right. And then the URL is

going to be the same. So it's going to be posts, and then we're going to need the ID. So we can figure out which post to actually delete. Right, then let's define our function. So I'm just going

to call this delete post. And so here, we have to implement the logic for deleting posts. So what

are we going to do? Well, for me, there's many different ways, you know, deleting a post is just

a matter of trying to figure out which specific dictionary within this array has a specific ID

of whatever ID we give it, and then we just remove it from the array. So however you want to do it, go ahead and do it. I'm going to just show you the first way that I thought of. Like I said,

this doesn't actually have anything to do with fast API, this is more of just simply working with Python. So I'm telling you right up front, this may not be the most efficient way to do it.

But like I said, we're eventually going to implement a real database. So it doesn't really matter how you do it as long as it works. And so the first thing that we're going to do is I'm going

to look to find the index in the array that has required ID, we're going to look for what we're

going to try to get the index of that specific item. And then all we're going to do is we'll do a my underscore posts, dot pop, and then just pass in the index. And so that's how we remove it from

that array. Pretty simple. And what I'm going to do is I'm going to actually just define a function out here, just to keep things simple. So this is going to be called find underscore index underscore

post. And then we're going to pass in the ID that we're interested in. And then we're going to iterate over the array. But we're also going to grab the specific index as we iterate over it. And so you

do that by using enumerate. So this is going to iterate over it, we'll get the access to the

individual posts that we're iterating over, as well as the index. And so we'll say, if P, if the ID

equals equals ID, and I forgot the n keyword here, we'll just return i. So this is going to give us

the index of the dictionary with that specific ID. So here, we can just call that function. And we'll

set it equal to the index. So index equals find underscore index of post pass an ID. So we now

have the index. And at this point, I can just do a my posts dot pop, and then just pass in index.

And then we'll try to do a return. And then here, I'm just going to pass in. We'll say message.

We'll say post was successfully deleted. Let's give this a shot. So first of all,

let's get all the posts. If I do a get all posts, you'll see that we have two posts. And then I'm

going to create a new request. And this will be called delete post. Copy that URL, pass it in

there. And so here, I'm going to try and delete with a post of a value of one. And I realized I

still left as get so we're gonna change the delete. And so now it throws an error. So what exactly

happened? Well, if we go back to here, and then go back to our console, it says, says non type object

cannot be interpreted as an integer. And, and I realized I forgot to actually pass in ID

into our function. So that's why it was giving us that error. But now let's try this again.

And we see that we get the message says post was successfully deleted. That's good. However,

you'll see that the status code is 200. And so if we actually go back to our status codes, you'll

see that there's a specific status code that we should be using for when we delete something. And

that status code is a 204. And like I said, you know, you can read the documentation, but this is something that just, you know, comes with time of working with API. So you'll know that anytime you

want to delete something, you want to use a 204. But before we actually do that, let's verify that

it actually deleted it. So we'll go to get posts. And I'll send a request. And we can see that there's only one post. So it clearly did work. But let's update the status code. So do you guys

remember how to update the status code, the default status code of a specific path operation,

we just pass in status code into the decorator. And then we'll do status. And then we'll just get our 204. Now let's try to delete something again. We'll try to delete, where's my delete?

We'll try to delete post one again, let's see what happens. So you'll see here that we get the 204. So everything looks good, we didn't get any data back. And if we go back to our application,

you'll see that we got a an error, which says too much data for declared content length. And what's

happening here is I actually had to look up this error. And that's because anytime you send back a 204, the idea is that since we delete anything, we shouldn't really be sending any data back.

And so when we try to send this message back, fast API essentially throws an error saying like, Listen, you're sending a 204, we should not be sending anything back. So that's how they kind

of implemented fast API. And so the what you should be doing is, if you want to do if you

what we should do is actually just delete this, we should grab the response. And then just pass

in status code status HTTP 204. Right? So basically, we don't want to actually send any data back

anytime someone delete something, we just want to send a 204. And then one of the requirements for that to work is that we don't send any data back. I know it's a little confusing. If you actually

just Google this error, you'll probably get better explanation. But 204, when you delete something,

you don't want to send any data back. That's kind of the expected result. So let's try this again.

Let's send it. All right, so we got the 204, no data comes back. And no errors. So that's all we

have to do. So this is just something special that you have to do for delete within fast API. Just keep that in mind. It's more of just a copy of a cut and paste type scenario. However, before we

wrap up this delete video, we are still running into one tiny issue. If I try to grab a an ID,

that doesn't exist, let's see what happens. Well, now we get a 500 error. And we get an error because

well, none type object cannot be interpreted as an integer. So since we tried to grab the index,

from this find index post, it's going to return nothing because there's no post that has an idea of five. So we get nothing. And then we try to pop with an index of non that creates an error.

So we need to put in a simple if statement to actually catch that scenario. So we'll say if index equals equals non, so return none, if it doesn't exist, what are we going to do? Well,

we're going to raise an exception again. So we can use that raise HTTP exception. And we'll just

say status code equals in this case, we want to send a 404 like we normally do. So we'll say status

dot HTTP 404. And then we can send a detailed message. So in this case, you know, we'll do once

again, another f string. And we'll say post with ID past the ID does not exist. Let's try this out.

Perfect 404 post with ID doesn't exist. Let's just make sure we didn't break the original functionality. We delete it. Perfect. And let's just double check there's no errors. There we go.

So everything looks good to go, guys. So we'll wrap up this video. And then in the next video,

we'll take a look at how we can update posts. All right, guys, we're almost done with all of

our credit operations. The final one is update. So let's create a new request. We're gonna call

this update post. And I'm just gonna grab the URL from the delete post, because it's gonna follow

the same exact structure. So we're gonna pass the ID of the post that we want to update.

Now, since we are updating it, we need our front end, or in this case, postman, to actually send the data that we want to update with. So since we are working with posts,

and we take a look at our structure of our posts, it's very simple, we just have title content,

and then, you know, published as well, if you want to add that in ratings as well. And I'm actually going to remove that. So I don't actually want to have that I'll actually

will keep it in for now. But we'll definitely remove that a little bit later on. And so if

I go back to postman, we can go to our body and then provide all of those fields. So we'll go to raw, and then JSON. But this is just like when we were trying to create a post, we just passed

that data in. And so here, we'll get the title. And we'll give it a new title. So updated title.

So this, this, this update request is just going to update the title. Now, we are going to use

the put method. So with put method, we have to actually pass in the data for all of the fields,

right, we want to pass in what the final post will look like after we update it, we don't just want to pass in the fields that we want to update. So if I go to let's say, you know, post one, right,

we have the title, and then we have the content. So if I wanted to update just the title, right,

I would make sure that I pass the content as well. So I'm just going to copy this. Since we're not updating, I'm just going to send back the same exact content.

All right, and then this is going to be a put operation. And so this is what the request is going to look like. Now, let's go to our code. And let's

actually create our path operation for that. So here, we're going to do app dot put is going

to go to posts ID. And then we'll define our function, I'm gonna call this update post. We're

gonna get the ID, and I'm gonna convert that to an int. And then one other thing, right, because

we are receiving data from the front end, just like we did for creating a post, we want to make

sure that it adheres to a very strict structure. So we get to use so I want to use our schema again,

so that the front end can't just send whatever it wants to. Now, I can create a new model called

class, you know, update post. And then we can pass in all the fields that we expect. However,

it's going to be the same thing as the post because we expect the title content. And then any of the other fields, depending on what we want, ultimately, but it's going to be a post. So

it doesn't make sense to create a new schema, we can just use the pre existing schema.

And so here, I'm just going to pass in post and make this type of post, so that it's going to

make sure that the request comes in with the right schema. And then for now, I'm just going

to hard code the return to be a message. And I'll just say, updated post. And then here,

I'm going to do a print, let's just see what the post looks like. All right, so we were able to

extract all of that data. So perfect. And then what we're going to do now is, there's a couple

things. So first things first, I need to find the index that of the post with this specific ID. So

just like we did with delete, I'm just going to copy this. Actually, we can copy all of this right here. Because if that ID doesn't exist, we want to send a 404. So we can reuse all of that logic.

But if we did find an index, that means we do need to update it. So what I'm going to do is we're going to grab post underscore dict, which equals post dot dict, that's going to take the

data we received from our front end, which is stored in post. And it's going to convert it to a dictionary. That's all it's doing. And then what I want to do is I want to set post underscore dict

of ID to be equal to ID. So we're going to set the ID inside this new dictionary to be that ID.

And then we're going to say my underscore post. And we're going to pass in the index of this

specific post we want to update and set that equal to post underscore dict. And then lastly,

we're going to return, I'll say data. And we're going to return our new post, which is going to

be post underscore dict. So let's just quickly recap what's happening. So first of all, the user

is going to send a put request to the specific ID of the post he wants to update. And we're going

to just do a quick check. So we're going to see if we can find what is the index of that specific post

within my my posts, Ray. If it doesn't exist, then we're gonna throw a 404. If it does exist,

whoops, if it doesn't exist, we're gonna throw a 404. If it does exist, well, first thing, we're going to take all the data we received from the front end, which is stored in post, we're going

to convert it to a regular Python dictionary. And then we're going to add the ID so that this final dictionary has the ID built in. And then we're going to say, for the post within index, we're

going to just replace it with our new post underscore dict. So that's how we update that specific spot

in the array. And so let's give this a shot. So if I do get all posts, right, we can see we have

post one, and then the title is title of post one. And then let's go to our update. And we can see that we're going to change the title to be updated title. And let's see if that works. Okay, so it

looks like it worked. We got back the new post. So let's do a get all posts again. And let's see

if it actually did update. And we can see that it did in fact, update. Now, just to just to make

sure everything else is good, let's also change the content. So let's say this is the new content.

Let's send an update. And then we're going to run this again. And we can see that the content is

updated. So now we're able to successfully update each and every post. And that's going to wrap up

all of our CRUD operations. So you can see that building out an API, building out your CRUD functionality is fairly straightforward within fast API. We've got one more lesson where we're

just going to restructure our code a little bit just to make things a little bit cleaner. And then we're going to start getting to the fun stuff, which is working with databases. So I'm going to

show you guys how we can actually get a Postgres database installed on our machines and running. And then we'll actually start saving data into an actual database. In this lesson, we're going to

talk about one of my favorite features of fast API. And that is the built in support for documentation.

So normally, when you build an API, you're going to want to create documentation so that users know how to use it. And one of the challenges with that is that it's not exactly a simple process. And

anytime you make changes to your API, you have to make sure that you update your documentation. And

it's very easy to forget to do that with fast API, fast API automatically generates the documentation

based off of the path operations that you've defined. So it does it all for you. And you don't have to write a single piece of code to actually get the documentation in place. And so to actually

see the documentation, you just go to the normal URL, but you just do slash docs. And so this is

going to show you the built in documentation powered by swagger UI. And so what's really nice is and if you've ever looked at the documentation for our some other API's, you may have noticed

something that looks similar to this. And that usually means that they used swagger UI as well. So fast API has built in swagger UI support, and it automatically generates all of the routes,

and the documentation for all of your paths. And so if you take a look at all of our operations, our path operations, we've got the one for getting all posts, we've got the one for creating posts,

we've got the one for getting an individual post, we got the one for updating an individual post, as well as deleting a post. And what's really cool about this is if we do hit the drop down,

right, it's going to show you how to use this specific path, or how to use this specific API

endpoint. So if you want to actually try it out, you can do that. So you could say try it out. And then you can just hit execute. And so now it actually ran the query against our API server,

and it shows us what the output is. So these are the two documents that we have, or the two posts that we've created. And we can do this with all of the API endpoints. So if we

want to create a new post, it's going to give you an example of the data that we can pass in,

so we can try try it out. And then it's going to give us all the fields that we have to pass in, and then we can just customize this. So if I want to say, creating new post with documents,

and then I'll just for content, I'll say this is really cool.

We'll give it a random rating, we hit execute, right, it actually runs that it's going to show

you how to perform the same actions using curl as well. And then it's going to show you the data

that we got back from our API server. And we can see that we got a 201 response code. And so I want

you guys to just kind of play around with this, get familiar with it. So there's going to be times where you may not even have to use a tool like postman, you could just test things out using

swagger UI in the built in documentation. And what's even nicer about this is that we have

built in support for two different types of documentation. So this is using swagger UI, but if you use redox, sorry, there shouldn't be an S at the end, it's just redoc, right,

you could see a different format of the documentation using a tool called redoc. So it's going to fundamentally do the same thing. It's just a different documentation tool. So it's

going to look a little different. Feel free to use whichever one you ultimately prefer. But by having it automatically get generated by fast API, you don't ever have to worry about updating

anything. So if you take a look at like create post, right, we've defined the pieces of data

that we need. And in the future, if we decide that the user needs to pass in another field,

maybe like the date that they wanted to get published, it'll automatically update this, you don't have to tell it you don't have to manually go in and update it yourself.

All right, guys, so we're going to make one slight change to how we structure our code. And what I want to do is instead of just having my main file within my base project directory,

I want to actually create a folder called app. So that's going to store all of our application specific code, and then put that main file in there. So it's a very small change. But we do

have to change a couple of things to make sure that it doesn't actually break anything. So I'm going to create a new folder. And I'm going to call this app. And so this in Python, if you

aren't too familiar with how Python works, Python has a concept of packages, and a package is nothing

more than a fancy name for a folder. However, for something to properly act as a package,

Python requires you to create a dummy file. And this file is called underscore underscore in it,

underscore underscore p y. All right, and so that's going to turn this into a proper Python package.

Just know that you have to add this file, you don't have to put anything in the file. But any time you create a new folder, just make sure you create a file with this exact name. And that's

going to ensure that it is in fact a Python package. So now that this is an actual Python

package, we can just drag this main file into our app folder. Right, and then now we're going to get

an error. And that's perfectly okay. So we're going to cancel out of this. And I want you to

take a look at the command that we run to start our application. So the command to start our application was we do uv corn, we do the name of the main file, which is just main. And then within

main, if you take a look at what's the name of our fast API instance, it's called app. However,

now when we run this command line, this command, it's going to look for a file named main. However,

there's no file named main within our base project directory, because it's now been moved into app. So to actually reference the main file that's inside of a Python package, it's pretty simple,

you just put the name of the package beforehand. So you do app, and then dot. So it's going to

tell uv coin to look inside the app directory for a file name main. So then we go in there,

we see the main file. And then within our main file, we look for the app instance, which is our fast API instance right here. Let's give this a shot. Let's see if we broke anything.

It looks like everything started out fine. I'm just going to do a couple of requests. So this is going to be just get an individual post. Looks like everything is good. I just want to make sure

that there's no errors. And yep, everything looks good. So I think this is just a little bit better of a way to structure our application, we're going to put all of our app code moving forward

inside of this app directory, so that we can keep everything else separate. I think at this point, we have a basic understanding of how to work with fast API,

and how to set up basic routes and work with path operations. Until now, we've been storing all of our posts in memory. And I think we've made it to a point where we are ready to now start working

with databases. And so if you don't know what a database is, a database is a collection of organized data that can be easily accessed and managed. And so when it comes to any kind of

application related data, so things like users that have registered posts that have been created, all of these pieces of information are going to be stored within a database. So it's going to be

stored on disk, so that we can retrieve this information at a later point in time. Now, when it comes to databases, we never actually interact with the databases directly. Instead,

what we have is a database management system that's going to sit in the middle. So when we

want to perform an operation on a database, we're going to send that request to a database management system, that management system is then going to actually perform that operation,

and then it's going to send the result back to us. So we never talked to the databases directly. Instead, we have a piece of software that sits in the middle and access the brains behind the

database. Now, there's two major branches of databases, there's relational and no SQL databases,

relational databases are usually SQL based databases. And we're going to cover that in the next slide or so. But these are just some of the more popular relational and no SQL databases

that you guys have probably heard of. In this course, we're going to work exclusively with relational databases. And more specifically, we're going to work with Postgres. Now, if you ultimately

want to learn how to work with MySQL or Oracle or SQL Server or any of the other databases, keep in mind that at the core, they are fundamentally no different than Postgres,

you know, 90, I would say 97% of the things that we cover when it comes to Postgres is going to be almost identical in all of these other databases, because they all at the end of the day,

use SQL. However, SQL, there is a little bit of slight nuances when it comes to each database,

each of them will implement it in a slightly different way. So you'll see that certain SQL commands aren't available in others. But for the most part, all of the core things that we cover

from a SQL perspective is going to be applicable to any of the other relational based databases.

And so let's talk about SQL now. So SQL or structured query language is a language that's used to communicate with the database management system. And so, you know, when we want to perform

an operation, we're going to send a specific SQL statement to the database management system, it's going to then take that statement and then perform the operation on the database.

And then it's going to send that result back to us. So SQL is the language that we use to communicate with the database management system. Now, in the next video, what we're going to do is we're going

to install Postgres on both Windows and Mac, depending on what you're using. And there's an important thing to note when it comes to installing Postgres, or really any database, when you install

an instance of Postgres, what we can actually do is we can carve out multiple separate databases,

right? And this is kind of confusing at first, because you're thinking, well, we installed Postgres, we have a database. Yes, but what we can do is we can actually create two different

databases that are completely isolate, isolated, and have nothing to do with one another. And that way, if I have application one, we can create a database just for app one. And then if I have a

second application that I create, this application can have a separate database as well. And there, these two databases are going to be completely separate, and completely isolated so that they

don't step on each other's toes. So it's pretty cool. And it's a pretty awesome feature to be able to kind of carve out your Postgres instance to multiple databases. And keep in mind that you

don't necessarily always create a separate database in database instance for each application,

right? There are scenarios where you might actually create an app that's going to make use of more than one database instance within Postgres. However, those are very specific situations,

maybe if you want some sort of multi tendency or things like that. However, we're just going to create one individual database instance for our application, that's going to handle everything

that we need. Now, when we install Postgres, what's going to happen is that the installation

process is going to create a database within the Postgres instance, called Postgres, little

confusing, right? It's Postgres within Postgres. But it's actually going to create this database named Postgres. And the reason we need to do this is that if you ever want to connect to a Postgres

instance, what you have to do is you have to specify a database that you want to connect to some some kind of default database that you want to connect to, you can't just connect to Postgres,

you have to specify a database. And so that's why the installation process creates one database for

you so that you can have something to connect to. However, we won't necessarily need that instance

once we create our own. However, I usually just keep it in by default, because it's not going to hurt anyone. In this video, we'll take a look at how we can install Postgres on a Windows machine.

So let's go ahead and just search for Postgres. And it's almost always going to be the first

instance. So just go to Postgres ql.org. And then we can just select the downloads button.

Here, go ahead and select Windows. And then up here, just like the download the installer link.

And so here, you'll see all of the downloads options. So right now, the latest version is 13.4. So I'm going to just download that one, you may see a newer version, feel free to download

that nothing's going to really change between each version. Once that's downloaded, start the

installer. If you see this pop up, just select Yes. With the installer open, select Next,